e43f9fa50c
Store a scrypt hash (migrating a plaintext password without changing it), sign sessions with a generation that ./password and --revoke-all rotate, make logout a same-origin POST that revokes the token, add sign out everywhere, and close proxied websockets whose session ends. Enforce a strength rule for new passwords, back off logins per client and server-wide, check Origin on login, tighten next, add security headers and a __Host- cookie over https.
254 lines
9.8 KiB
Python
254 lines
9.8 KiB
Python
#!/usr/bin/env python3
|
|
"""Change the local Pipelines web sign-in password, or sign out every device.
|
|
|
|
The password is stored only as a scrypt hash. Every change (and --revoke-all)
|
|
rotates the cookie secret and the session generation, so each signed-in
|
|
browser and device must sign in again; open connections are closed within a
|
|
few seconds. No service restart is needed.
|
|
"""
|
|
import argparse
|
|
import base64
|
|
import fcntl
|
|
import getpass
|
|
import hashlib
|
|
import hmac
|
|
import json
|
|
import os
|
|
from pathlib import Path
|
|
import re
|
|
import secrets
|
|
import stat
|
|
import sys
|
|
import tempfile
|
|
|
|
# scrypt cost: 32 MiB and roughly a tenth of a second per check. The hash
|
|
# records its parameters, so they can be raised later without a migration.
|
|
SCRYPT_N, SCRYPT_R, SCRYPT_P, SCRYPT_KEY = 1 << 15, 8, 1, 32
|
|
SCRYPT_MAXMEM = 64 * 1024 * 1024
|
|
|
|
PASSWORD_RULE = ("Use at least 16 characters, or a passphrase of 4 or more random words "
|
|
"separated by spaces or dashes (15 characters or more in all). Common words, "
|
|
"keyboard runs and repeated characters do not count towards the length.")
|
|
|
|
# Kept in step with web/src/passwordPolicy.js.
|
|
COMMON = ("password", "passwort", "pipelines", "pipeline", "qwerty", "azerty", "letmein",
|
|
"welcome", "admin", "administrator", "iloveyou", "monkey", "dragon", "master",
|
|
"secret", "login", "changeme", "default", "football", "baseball", "sunshine",
|
|
"princess", "shadow", "trustno", "superman", "hello", "test", "guest", "root")
|
|
SEPARATORS = re.compile(r"[\s\-_.,;:+/]+")
|
|
|
|
|
|
def _runs(text):
|
|
"""Remove runs of 3+ repeated characters and 4+ consecutive characters."""
|
|
out, i = [], 0
|
|
while i < len(text):
|
|
j = i + 1
|
|
while j < len(text) and text[j] == text[i]:
|
|
j += 1
|
|
if j - i >= 3:
|
|
i = j
|
|
continue
|
|
for step in (1, -1):
|
|
j = i + 1
|
|
while j < len(text) and ord(text[j]) - ord(text[j - 1]) == step:
|
|
j += 1
|
|
if j - i >= 4:
|
|
break
|
|
else:
|
|
out.append(text[i])
|
|
i += 1
|
|
continue
|
|
i = j
|
|
return "".join(out)
|
|
|
|
|
|
def _substance(password):
|
|
"""The characters left once common words, runs and separators are removed."""
|
|
text = password.lower()
|
|
for word in sorted(COMMON, key=len, reverse=True):
|
|
text = text.replace(word, "")
|
|
for row in ("qwertyuiop", "asdfghjkl", "zxcvbnm", "1234567890"):
|
|
for size in range(len(row), 3, -1):
|
|
for start in range(len(row) - size + 1):
|
|
text = text.replace(row[start:start + size], "")
|
|
return SEPARATORS.sub("", _runs(text))
|
|
|
|
|
|
def password_problem(password):
|
|
"""Why a new password is too weak, or None. See PASSWORD_RULE."""
|
|
if len(password) > 1024:
|
|
return "Choose a password of at most 1024 characters."
|
|
words = [word.lower() for word in SEPARATORS.split(password) if word]
|
|
passphrase = (len(words) >= 4 and len(set(words)) >= 4 and all(len(word) >= 3 for word in words)
|
|
and len(password) >= 15 and len(_substance(password)) >= 12)
|
|
if passphrase:
|
|
return None
|
|
if len(password) < 16:
|
|
return "Too short. " + PASSWORD_RULE
|
|
if len(set(password)) < 8 or len(_substance(password)) < 12:
|
|
return "Too predictable. " + PASSWORD_RULE
|
|
return None
|
|
|
|
|
|
def _b64(raw):
|
|
return base64.urlsafe_b64encode(raw).rstrip(b"=").decode()
|
|
|
|
|
|
def hash_password(password, *, n=SCRYPT_N, r=SCRYPT_R, p=SCRYPT_P):
|
|
salt = secrets.token_bytes(16)
|
|
key = hashlib.scrypt(password.encode(), salt=salt, n=n, r=r, p=p, maxmem=SCRYPT_MAXMEM, dklen=SCRYPT_KEY)
|
|
return f"scrypt${n}${r}${p}${_b64(salt)}${_b64(key)}"
|
|
|
|
|
|
def verify_password(stored, candidate):
|
|
"""Constant-time check of candidate against a stored scrypt hash."""
|
|
try:
|
|
scheme, n, r, p, salt, key = stored.split("$")
|
|
if scheme != "scrypt":
|
|
return False
|
|
pad = lambda value: base64.urlsafe_b64decode(value + "=" * (-len(value) % 4))
|
|
expected = pad(key)
|
|
derived = hashlib.scrypt(candidate.encode(), salt=pad(salt), n=int(n), r=int(r), p=int(p),
|
|
maxmem=SCRYPT_MAXMEM, dklen=len(expected))
|
|
except (ValueError, TypeError):
|
|
return False
|
|
return hmac.compare_digest(derived, expected)
|
|
|
|
|
|
def auth_path(*, prefix=None, home=None, environ=None):
|
|
home = Path(home or Path.home())
|
|
env = os.environ if environ is None else environ
|
|
selected = Path(prefix or env.get("PIPELINES_PREFIX") or home / ".local/share/pipelines").expanduser().resolve()
|
|
explicit = env.get("PIPELINES_WEB_AUTH_FILE")
|
|
if explicit:
|
|
return Path(explicit).expanduser().absolute()
|
|
manifest = selected / "pipelines-install.json"
|
|
if manifest.exists():
|
|
if manifest.is_symlink() or manifest.stat().st_uid != os.getuid():
|
|
raise ValueError("Refusing an unsafe installation manifest")
|
|
data = json.loads(manifest.read_text())
|
|
if data.get("format") != 1 or data.get("prefix") != str(selected):
|
|
raise ValueError("Invalid Pipelines installation manifest")
|
|
recorded = (data.get("web") or {}).get("auth_file")
|
|
if recorded:
|
|
return Path(recorded).expanduser().absolute()
|
|
return home / ".config/pipelines/web-auth.json"
|
|
|
|
|
|
def valid_auth(data):
|
|
"""Whether data is a usable web auth file: a scrypt hash (or a legacy
|
|
plaintext password the proxy has not migrated yet) and a cookie secret."""
|
|
if not isinstance(data, dict) or not isinstance(data.get("secret"), str) or len(data["secret"]) < 32:
|
|
return False
|
|
stored = data.get("password_hash")
|
|
if isinstance(stored, str):
|
|
return stored.startswith("scrypt$") and stored.count("$") == 5
|
|
return isinstance(data.get("password"), str) and len(data["password"]) >= 8
|
|
|
|
|
|
def read_auth(path):
|
|
path = Path(path)
|
|
info = path.lstat()
|
|
if not stat.S_ISREG(info.st_mode) or info.st_uid != os.getuid():
|
|
raise ValueError("Password file must be a regular file owned by this user")
|
|
if info.st_mode & 0o077:
|
|
raise ValueError(f"Password file must be private: chmod 600 '{path}'")
|
|
data = json.loads(path.read_text())
|
|
if not valid_auth(data):
|
|
raise ValueError("Invalid Pipelines password file; it was retained unchanged")
|
|
return data, info
|
|
|
|
|
|
def _rotate(data):
|
|
"""Invalidate every session: a new cookie secret and session generation."""
|
|
generation = data.get("generation")
|
|
data["generation"] = (generation if isinstance(generation, int) and generation >= 0 else 0) + 1
|
|
data["secret"] = secrets.token_urlsafe(48)
|
|
|
|
|
|
def update_auth(path, mutate):
|
|
"""Apply mutate to the auth file atomically, under a directory lock."""
|
|
path = Path(path)
|
|
# Lock the directory inode, which remains stable across atomic file replaces.
|
|
directory = os.open(path.parent, os.O_RDONLY)
|
|
try:
|
|
fcntl.flock(directory, fcntl.LOCK_EX)
|
|
data, original = read_auth(path)
|
|
mutate(data)
|
|
descriptor, temporary = tempfile.mkstemp(prefix=".pipelines-password-", dir=path.parent)
|
|
try:
|
|
with os.fdopen(descriptor, "w") as output:
|
|
os.fchmod(output.fileno(), 0o600)
|
|
json.dump(data, output, indent=2)
|
|
output.write("\n")
|
|
output.flush()
|
|
os.fsync(output.fileno())
|
|
current = path.lstat()
|
|
if (current.st_dev, current.st_ino, current.st_mtime_ns, current.st_size) != (original.st_dev, original.st_ino, original.st_mtime_ns, original.st_size):
|
|
raise ValueError("Password file changed during the update; retry the command")
|
|
os.replace(temporary, path)
|
|
finally:
|
|
Path(temporary).unlink(missing_ok=True)
|
|
finally:
|
|
os.close(directory)
|
|
|
|
|
|
def change_password(path, password):
|
|
problem = password_problem(password)
|
|
if problem:
|
|
raise ValueError(problem)
|
|
stored = hash_password(password)
|
|
|
|
def mutate(data):
|
|
data.pop("password", None)
|
|
data["password_hash"] = stored
|
|
data["password_weak"] = False
|
|
_rotate(data)
|
|
|
|
update_auth(path, mutate)
|
|
|
|
|
|
def revoke_all(path):
|
|
update_auth(path, _rotate)
|
|
|
|
|
|
def main():
|
|
parser = argparse.ArgumentParser(description=__doc__, formatter_class=argparse.RawDescriptionHelpFormatter)
|
|
parser.add_argument("--prefix", type=Path, help="Installation prefix (or PIPELINES_PREFIX)")
|
|
parser.add_argument("--revoke-all", action="store_true",
|
|
help="Sign out every browser and device without changing the password")
|
|
args = parser.parse_args()
|
|
path = auth_path(prefix=args.prefix)
|
|
data, _ = read_auth(path)
|
|
if args.revoke_all:
|
|
revoke_all(path)
|
|
print("Every browser and device was signed out; sign in again with the same password.")
|
|
return
|
|
if not sys.stdin.isatty():
|
|
raise ValueError("Run ./password in an interactive terminal (SSH with a TTY is supported)")
|
|
if data.get("password_weak") is True:
|
|
print("Warning: the current web password is weak. " + PASSWORD_RULE, file=sys.stderr)
|
|
print(PASSWORD_RULE)
|
|
while True:
|
|
password = getpass.getpass("New Pipelines password: ")
|
|
problem = password_problem(password)
|
|
if problem:
|
|
print(problem, file=sys.stderr)
|
|
continue
|
|
confirmation = getpass.getpass("Confirm new password: ")
|
|
if password != confirmation:
|
|
print("Passwords do not match. Try again.", file=sys.stderr)
|
|
else:
|
|
break
|
|
change_password(path, password)
|
|
print("Web sign-in password changed. No service restart is needed.")
|
|
print("Every browser and device was signed out and must sign in with the new password.")
|
|
print("The notification password is unchanged.")
|
|
|
|
|
|
if __name__ == "__main__":
|
|
try:
|
|
main()
|
|
except (OSError, ValueError, KeyboardInterrupt) as error:
|
|
sys.exit(f"Password not changed: {error}")
|