Skip to content

Local UI to run and train LLMs and diffusion models. Supports GGUF, MLX, Qwen3.8, DeepSeek-V4.1, MiniMax-H3, Gemma 4, FLUX and more.

13.2 KB
Raw Blame
# SPDX-License-Identifier: AGPL-3.0-only
# Copyright 2026-present the Unsloth AI Inc. team. All rights reserved. See /studio/LICENSE.AGPL-3.0

"""Masks credentials in logs on read; anchored on known prefixes or key names, never generic entropy."""

from __future__ import annotations

import re

REDACTED = "<redacted>"

# Strip ANSI first, as escapes defeat the anchored rules. Output must stay identical to the old regex: fixing truncated cases moved a leak.
_CSI_7BIT_RE = re.compile(r"\x1b\[[0-?]*[ -/]*[@-~]")
_CSI_8BIT_RE = re.compile(r"\x9b[0-?]*[ -/]*[@-~]")
# Fe covers 0x40-0x5F, so it also claims a "]" or "P" whose control string never terminated. Hence tried last.
_FE_RE = re.compile(r"\x1b[@-Z\\-_]")
_ANSI_INTRODUCER_RE = re.compile(r"[\x1b\x90\x98\x9b\x9d-\x9f]")
_C1_STRING_INTRODUCERS = "\x9d\x90\x98\x9e\x9f"


def _strip_ansi(text: str) -> str:
    """Remove terminal control sequences. Same output as the lazy alternation this replaces, in linear time."""
    first = _ANSI_INTRODUCER_RE.search(text)
    if first is None:
        return text
    out: list[str] = []
    written = 0
    index = first.start()
    length = len(text)
    # index only moves forward, so a cached hit at or after it is still the next one and a cached miss stays a miss. This is what makes the scan linear.
    found: dict[str, int] = {}

    def next_index(needle: str, start: int) -> int:
        cached = found.get(needle, -2)
        if cached == -1:
            return -1
        if cached == -2 or cached < start:
            cached = text.find(needle, start)
            found[needle] = cached
        return cached

    def string_end(terminators: tuple[str, ...], start: int) -> int:
        """End of the shortest body, which is what a lazy quantifier picks."""
        best, best_length = -1, 0
        for terminator in terminators:
            at = next_index(terminator, start)
            if at >= 0 and (best < 0 or at < best):
                best, best_length = at, len(terminator)
        return best + best_length if best >= 0 else -1

    while index < length:
        char = text[index]
        end = -1
        if char == "\x1b" and index + 1 < length and text[index + 1] == "]":
            end = string_end(("\x07", "\x1b\\", "\x9c"), index + 2)
        elif char == "\x1b" and index + 1 < length and text[index + 1] in "P^_X":
            end = string_end(("\x1b\\", "\x9c"), index + 2)
        elif char in _C1_STRING_INTRODUCERS:
            end = string_end(("\x07", "\x9c"), index + 1)
        if end < 0:
            if char == "\x1b":
                match = _CSI_7BIT_RE.match(text, index) or _FE_RE.match(text, index)
            elif char == "\x9b":
                match = _CSI_8BIT_RE.match(text, index)
            else:
                match = None
            end = match.end() if match else -1
        if end < 0:
            # Skip to the next introducer, not the next character, so ordinary text is never walked one character at a time.
            following = _ANSI_INTRODUCER_RE.search(text, index + 1)
            if following is None:
                break
            index = following.start()
            continue
        out.append(text[written:index])
        written = end
        following = _ANSI_INTRODUCER_RE.search(text, end)
        index = following.start() if following else length
    out.append(text[written:])
    return "".join(out)


# Key names whose VALUE is a secret. "token" alone is absent on purpose, so n_tokens = 4096 and token_id=128009 survive.
_SECRET_KEYS = (
    "authorization|x-api-key|api[-_]?key|apikey|hf[-_]?token|access[-_]?token|"
    "refresh[-_]?token|auth[-_]?token|bearer[-_]?token|client[-_]?secret|"
    "aws_secret_access_key|aws_session_token|wandb[-_]?token|hub[-_]?token|"
    # Unsloth's own S3 field (models/training.py:60) and its camelCase alias: neither is reachable through the bare "secret" alternative, and an AWS secret key has no prefix of its own for a shape rule to catch.
    "secret[-_]?access[-_]?key|"
    "password|passwd|secret"
)

# No leading word boundary, since "_" is a word character and one never fires inside OPENAI_API_KEY / db_password, the shape an env dump or argv line carries; the trailing boundary stays, so eos_token_id and secret_sauce_path are left alone.
_KEY_START = r"(?<![A-Za-z0-9])"

_PATTERNS: tuple[tuple[re.Pattern[str], str], ...] = (
    # Hugging Face
    (re.compile(r"\bhf_(?:oauth_[A-Za-z0-9._~+/=-]{20,}|[A-Za-z0-9]{20,})"), "hf_" + REDACTED),
    # OpenAI and other sk- keys (project, Anthropic, OpenRouter). Not a word boundary: that also fires after a hyphen, eating checkpoint-sk-9f8a... in a filename.
    (
        re.compile(r"(?<![A-Za-z0-9-])sk-(?:proj-|ant-api\d{2}-|or-v1-)?[A-Za-z0-9_-]{16,}"),
        "sk-" + REDACTED,
    ),
    # Other vendor prefixes
    (
        re.compile(
            r"\b(?:gsk_|xai-|ghp_|gho_|ghu_|ghs_|ghr_|github_pat_|glpat-|"
            r"xox[abpsr]-|ya29\.)[A-Za-z0-9_.-]{16,}"
        ),
        REDACTED,
    ),
    (re.compile(r"\bAIza[0-9A-Za-z_-]{30,}"), REDACTED),
    (re.compile(r"\b(?:AKIA|ASIA)[0-9A-Z]{16}\b"), REDACTED),
    # JWTs, including the desktop access token
    (re.compile(r"\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{5,}"), REDACTED),
    # user:password@host in a URL
    (re.compile(r"://[^/\s:@]+:[^/\s@]+@"), "://" + REDACTED + "@"),
    # Presigned URL parameters. Bare "key" is deliberately absent: in an object storage URL it names the object, and blanking it hides WHICH download failed. Google's ?key=AIza... is caught by the AIza rule above.
    (
        re.compile(
            r"(?i)([?&](?:token|api[-_]key|apikey|sig|signature|x-amz-signature|"
            r"x-amz-credential|x-amz-security-token|access_token)=)[^&\s\"']+"
        ),
        r"\1" + REDACTED,
    ),
)

# The QUOTED branch wins whenever an opening quote is there: stopping at whitespace turned password="correct horse battery staple" into a mask that leaked all but the first word. The value pattern matches a non-quote character or an escape rather than a lazy ".*?", so an escaped quote does not end the value early, and a newline is excluded so an unterminated quote cannot run the mask past its own line.
_QUOTED_VALUE = r"(?:[^\"'\\\n]|\\.){6,}"
_KV_RE = re.compile(
    r"(?i)" + _KEY_START + r"(?P<key>" + _SECRET_KEYS + r")\b"
    r"(?P<sep>[\"']?\s*[:=]\s*(?P<q>[\"'])?)"
    r"(?P<val>(?(q)" + _QUOTED_VALUE + r"|[^\"'\s,}\]]{6,}))"
)
_FLAG_RE = re.compile(
    r"(?i)(?P<key>--(?:" + _SECRET_KEYS + r"))"
    r"(?P<sep>\s+(?P<q>[\"'])?)"
    r"(?P<val>(?(q)" + _QUOTED_VALUE + r"|[^\s\"']{6,}))"
)

# An Authorization value whatever the scheme: the key/value rule captures only "Basic" and leaves the credential behind it. Same for a Cookie, which for Unsloth is the UI session.
_SCHEMES = ("bearer", "basic", "digest", "token", "apikey")
# A scheme word only introduces a credential when an Authorization header put it there, and the credential stops at a quote or structural delimiter, since \S+ swallowed the rest of the dict. Bare "digest sha256:..." and "token hf_..." are ordinary log content, and firing on the word alone blanked the digest a user came here to read.
_CREDENTIAL = r"[^\s\"',}\]]+"
_AUTH_HEADER_RE = re.compile(
    r"(?i)((?:proxy-)?authorization[\"']?\s*[:=]\s*[\"']?"
    r"(?:" + "|".join(_SCHEMES) + r"))(\s+)(" + _CREDENTIAL + r")"
)
# Bearer is not an English word that shows up in a log on its own, so it keeps a header-less rule; the shape guard still spares "Bearer credentials expired".
_SCHEME_RE = re.compile(r"(?i)\b(Bearer)(\s+)(" + _CREDENTIAL + r")")
# MULTILINE: this also runs over exception text.
_COOKIE_RE = re.compile(
    r"(?i)\b(?P<key>(?:set-)?cookie)(?P<sep>[\"']?\s*[:=]\s*(?P<q>[\"'])?)(?P<val>\S.*)$",
    re.MULTILINE,
)

# Keys whose value is a secret even when it is all digits (a numeric password is still a password); everywhere else a bare number is a count or an id.
_NUMERIC_IS_STILL_SECRET = re.compile(r"(?i)pass(word|wd)?$|secret$")


def _looks_like_credential(value: str) -> bool:
    """Token-shaped rather than an English word. Guards the rules keyed on a weak name: "Bearer credentials were not accepted" and "Cookie: disabled" are log content, and blanking them hides the failure being diagnosed."""
    if len(value) < 8:
        return False
    if len(value) >= 20:
        return True
    has_digit = any(char.isdigit() for char in value)
    has_symbol = any(char in "._-+/=~" for char in value)
    mixed_case = any(char.isupper() for char in value) and any(char.islower() for char in value)
    return has_digit or has_symbol or mixed_case


def _redact_kv(match: re.Match[str]) -> str:
    # Named groups: the quoted/unquoted branch adds a group, so positional numbering is not stable.
    value = match.group("val")
    if value.isdigit() and not _NUMERIC_IS_STILL_SECRET.search(match.group("key")):
        return match.group(0)
    # Quoting puts the scheme inside the value ('authorization': 'Basic abc'). Step over it rather than abandon the match: the rest is still the credential, and blanking the scheme reads as if the header were the secret.
    scheme, sep, rest = value.partition(" ")
    if scheme.lower() in _SCHEMES:
        if not sep or not rest.strip():
            return match.group(0)
        return f"{match.group('key')}{match.group('sep')}{scheme}{sep}{REDACTED}"
    return f"{match.group('key')}{match.group('sep')}{REDACTED}"


def _redact_shaped(match: re.Match[str]) -> str:
    if not _looks_like_credential(match.group(3)):
        return match.group(0)
    return f"{match.group(1)}{match.group(2)}{REDACTED}"


# A cookie header is name=value pairs.
_COOKIE_PAIR_RE = re.compile(r"^[A-Za-z0-9_.\-]+=\S")


def _redact_cookie(match: re.Match[str]) -> str:
    value, tail = match.group("val"), ""
    # A quoted value ends at its closing quote, so the fields behind it in a header dict survive instead of disappearing into the mask.
    quote = match.group("q")
    if quote:
        end = value.find(quote)
        if end != -1:
            value, tail = value[:end], value[end:]
    if not _COOKIE_PAIR_RE.match(value.strip()):
        return match.group(0)
    return f"{match.group('key')}{match.group('sep')}{REDACTED}{tail}"


# Per _PATTERNS rule, literals every match contains (None = always run). Those rules are case-sensitive, so substring tests are exact.
_PATTERN_LITERALS: tuple[tuple[str, ...] | None, ...] = (
    ("hf_",),
    ("sk-",),
    (
        "gsk_",
        "xai-",
        "ghp_",
        "gho_",
        "ghu_",
        "ghs_",
        "ghr_",
        "github_pat_",
        "glpat-",
        "xox",
        "ya29.",
    ),
    ("AIza",),
    ("AKIA", "ASIA"),
    ("eyJ",),
    None,
    ("=",),
)
_PATTERN_GATES: tuple[re.Pattern[str] | None, ...] = tuple(
    None if literals is None else re.compile("|".join(re.escape(literal) for literal in literals))
    for literals in _PATTERN_LITERALS
)
if len(_PATTERN_GATES) != len(_PATTERNS):
    raise RuntimeError("every _PATTERNS rule needs an entry in _PATTERN_GATES")

_SECRET_KEY_WORDS = ("authorization", "key", "token", "secret", "pass")
if not all(any(word in key for word in _SECRET_KEY_WORDS) for key in _SECRET_KEYS.split("|")):
    raise RuntimeError("every _SECRET_KEYS alternative needs a word in _SECRET_KEY_WORDS")
# Off ASCII, IGNORECASE folds e.g. the Kelvin sign onto "k", so the engine decides.
_FOLDED_GATE_RES = {
    words: re.compile("(?i)" + "|".join(words))
    for words in (("authorization",), ("bearer",), ("cookie",), _SECRET_KEY_WORDS)
}


def _has_folded(text: str, lowered: str | None, words: tuple[str, ...]) -> bool:
    if lowered is None:
        return _FOLDED_GATE_RES[words].search(text) is not None
    for word in words:
        if word in lowered:
            return True
    return False


def _lowered(text: str) -> str | None:
    return text.lower() if text.isascii() else None


def redact_log_text(text: str) -> str:
    """Mask credentials. Idempotent, and a no-op on ordinary log content."""
    if not text:
        return text
    # Nothing anchored below survives an escape between a key and its value, so strip first, guarded by one introducer scan: ordinary content is untouched.
    if _ANSI_INTRODUCER_RE.search(text):
        text = _strip_ansi(text)
    for (pattern, replacement), gate in zip(_PATTERNS, _PATTERN_GATES):
        if gate is None or gate.search(text) is not None:
            text = pattern.sub(replacement, text)
    lowered = _lowered(text)
    # Before the key/value rules: _KV_RE captures "Basic" from "Authorization: Basic dXNlcjpwdw==", masking the scheme and leaving the credential clear.
    if _has_folded(text, lowered, ("authorization",)):
        text = _AUTH_HEADER_RE.sub(_redact_shaped, text)
        lowered = _lowered(text)
    if _has_folded(text, lowered, ("bearer",)):
        text = _SCHEME_RE.sub(_redact_shaped, text)
        lowered = _lowered(text)
    if _has_folded(text, lowered, ("cookie",)):
        text = _COOKIE_RE.sub(_redact_cookie, text)
        lowered = _lowered(text)
    if (":" in text or "=" in text) and _has_folded(text, lowered, _SECRET_KEY_WORDS):
        text = _KV_RE.sub(_redact_kv, text)
        lowered = _lowered(text)
    if "--" in text and _has_folded(text, lowered, _SECRET_KEY_WORDS):
        text = _FLAG_RE.sub(_redact_kv, text)
    try:
        from utils.native_path_leases import redact_native_paths
        text = redact_native_paths(text)
    except Exception:
        pass
    return text