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.
Python agentaichatgptdeepseekfine-tuninggemmaimage-generationllamallmllmsopenaipythonqwenreinforcement-learningself-hostedstable-diffusiontext-to-speechttsuiunsloth
# 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