138 lines
5.1 KiB
Python
138 lines
5.1 KiB
Python
"""Password handling: clear storage or compare, fast hash, log, literal."""
|
|
import re
|
|
|
|
from .common import Rule, SOURCE_EXTS, non_doc_files, redact
|
|
|
|
DOMAIN = "api"
|
|
NAME = r"(?:password|passwd|pwd|mot_de_passe)"
|
|
CONFIG_EXTS = {".yml", ".yaml", ".toml", ".ini", ".cfg", ".conf", ".sh",
|
|
".properties", ".json"}
|
|
SKIP_PATH = re.compile(
|
|
r"\.(?:test|spec|e2e|stories)\.|(?:^|/)(?:tests?|__tests__|spec|e2e"
|
|
r"|fixtures?|i18n|locales?|lang|translations?|messages)/", re.I)
|
|
HASH_EVIDENCE = (
|
|
r"bcrypt|argon2|scrypt|pbkdf2|password_hash\(|password_verify\("
|
|
r"|Hash::make|make_password|hashpw|PasswordHasher|hash_password"
|
|
r"|verify_password|\bphpass\b")
|
|
COLUMN = (
|
|
rf"\b{NAME}\s+(?:text|varchar|character varying|char|citext|string)\b"
|
|
rf"|->string\(\s*['\"]{NAME}['\"]"
|
|
rf"|\b{NAME}\s*=\s*models\.(?:Char|Text)Field"
|
|
rf"|\b{NAME}\s*:\s*(?:text|varchar)\(")
|
|
COMPARE = (
|
|
rf"(?:\.|->|\[['\"]){NAME}['\"]?\]?\s*[!=]==?\s*[\w$]"
|
|
rf"|[\w$\]\)]\s*[!=]==?\s*\$?\w+(?:\.|->){NAME}\b"
|
|
rf"|\b(?:where|and)\s+(?:\w+\.)?{NAME}\s*=\s*(?:\$\d+|\?|:\w+|%s)")
|
|
COMPARE_SKIP = re.compile(
|
|
r"confirm|repeat|again|undefined|null|hash|digest|length", re.I)
|
|
WEAK_HASH = (
|
|
rf"\b(?:md5|sha1|sha256|sha512|crc32|hashlib\.\w+)\s*\(\s*[^()\n]*{NAME}"
|
|
rf"|createHash\([^)\n]*\)\s*\.update\(\s*[^()\n]*{NAME}"
|
|
rf"|\bhash\(\s*['\"](?:md5|sha1|sha256|sha512)['\"]\s*,\s*[^()\n]*{NAME}")
|
|
WEAK_SKIP = re.compile(r"token|reset|otp|nonce|session", re.I)
|
|
LOG_CALL = (
|
|
r"\b(?:console\.\w+|logger?\.\w+|log\.\w+|logging\.\w+|print(?:ln!?)?"
|
|
r"|error_log|Log::\w+|tracing::\w+!|dbg!|var_dump|print_r)\s*\(([^\n]*)")
|
|
STRING = re.compile(r"'[^'\n]*'|\"[^\"\n]*\"|`[^`\n]*`")
|
|
LOGGED_NAME = re.compile(
|
|
rf"\b(?:(?:new|old|plain|raw|user|current)_?)?{NAME}\b|\bcredentials\b",
|
|
re.I)
|
|
LITERAL = rf"\b(\w*{NAME})['\"]?\s*(?:[:=]|=>)\s*['\"]([^'\"\n]{{8,}})['\"]"
|
|
BARE_LITERAL = rf"\b(\w*{NAME})(?:=\s*|:\s+)([^'\"\s#]{{8,}})"
|
|
PLACEHOLDER = re.compile(
|
|
r"change|your|xxx|\*\*|example|placeholder|dummy|sample|secret[-_ ]?here"
|
|
r"|^[$%<{.*/]|\||required|^\$argon|^[0-9a-f]{32,}$|^[a-z]+(?:_[a-z]+)+$| ",
|
|
re.I)
|
|
PLAINTEXT = Rule(DOMAIN, "API-PASSWORD-PLAINTEXT", "FAIL")
|
|
LITERAL_RULE = Rule(DOMAIN, "API-PASSWORD-LITERAL", "WARN")
|
|
|
|
|
|
def _line(text, offset):
|
|
start = text.rfind("\n", 0, offset) + 1
|
|
end = text.find("\n", offset)
|
|
return text[start:] if end < 0 else text[start:end]
|
|
|
|
|
|
def _files(project):
|
|
return [p for p in non_doc_files(project)
|
|
if not SKIP_PATH.search(project.rel(p))]
|
|
|
|
|
|
def check(project):
|
|
files = _files(project)
|
|
return (_columns(project, files) + _compares(project, files)
|
|
+ _weak_hash(project, files) + _logged(project, files)
|
|
+ _literals(project, files))
|
|
|
|
|
|
def _columns(project, files):
|
|
if project.has(HASH_EVIDENCE, files):
|
|
return []
|
|
return [
|
|
project.found(
|
|
PLAINTEXT, path, m.start(),
|
|
"password column and no hashing library anywhere: store an "
|
|
"argon2id or bcrypt hash, never the password")
|
|
for path, m in project.matches(COLUMN, files)
|
|
]
|
|
|
|
|
|
def _compares(project, files):
|
|
return [
|
|
project.found(
|
|
PLAINTEXT, path, m.start(),
|
|
"stored password compared in clear: verify a hash with the "
|
|
"library's constant-time check")
|
|
for path, m in project.matches(COMPARE, files)
|
|
if not COMPARE_SKIP.search(_line(project.text(path), m.start()))
|
|
]
|
|
|
|
|
|
def _weak_hash(project, files):
|
|
return [
|
|
project.found(
|
|
Rule(DOMAIN, "API-PASSWORD-WEAK-HASH", "FAIL"), path, m.start(),
|
|
"password through a fast hash: use argon2id, scrypt or bcrypt")
|
|
for path, m in project.matches(WEAK_HASH, files)
|
|
if not WEAK_SKIP.search(_line(project.text(path), m.start()))
|
|
]
|
|
|
|
|
|
def log_args(args):
|
|
"""Call arguments with string literals reduced to their interpolations."""
|
|
return STRING.sub(
|
|
lambda m: " ".join(re.findall(r"\{([^}]*)\}", m.group())), args)
|
|
|
|
|
|
def _logged(project, files):
|
|
return [
|
|
project.found(
|
|
Rule(DOMAIN, "API-PASSWORD-LOGGED", "FAIL"), path, m.start(),
|
|
"password reaches a log: never log credentials")
|
|
for path, m in project.matches(LOG_CALL, files)
|
|
if LOGGED_NAME.search(log_args(m.group(1)))
|
|
]
|
|
|
|
|
|
def _is_placeholder(key, value):
|
|
return value.lower() == key.lower() or bool(PLACEHOLDER.search(value))
|
|
|
|
|
|
def _literal_hits(project, files, pattern):
|
|
return [
|
|
project.found(
|
|
LITERAL_RULE, path, m.start(),
|
|
f"{m.group(1)} set to a literal ({redact(m.group(2))}): a real "
|
|
"credential moves to env and gets rotated; a dev default is "
|
|
"documented as such")
|
|
for path, m in project.matches(pattern, files)
|
|
if not _is_placeholder(m.group(1), m.group(2))
|
|
]
|
|
|
|
|
|
def _literals(project, files):
|
|
config = [p for p in files if p.suffix.lower() in CONFIG_EXTS]
|
|
source = [p for p in files if p.suffix.lower() in SOURCE_EXTS]
|
|
return (_literal_hits(project, source + config, LITERAL)
|
|
+ _literal_hits(project, config, BARE_LITERAL))
|