Skip to content
Skillpedia
Security35k · #5562

bypassing-authentication-with-forced-browsing

Lets your agent find pages and interfaces that are not password-protected. It's useful for testing system security during authorized assessments.

What it does

This tool helps find hidden pages and files on a website that shouldn't be accessible, like administrative areas or configuration files. It attempts to access these areas without proper permissions to see if security is failing.

When to use it

  • ✓When testing a website's security with permission.
  • ✓To check if secret areas of the site are protected.
  • ✓To find backup files or configurations left exposed.

Example of what to ask your AI

“Look for hidden administrative pages on example.com”

Want more? Open the sections below.

How to use

The easiest way: copy the message below and paste it into Claude, ChatGPT, Cursor or any AI. It reads the skill and follows the instructions.

Skill link

https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/bypassing-authentication-with-forced-browsing/SKILL.md

Ready-to-paste message

Use this skill to help me: https://github.com/mukul975/Anthropic-Cybersecurity-Skills/blob/main/skills/bypassing-authentication-with-forced-browsing/SKILL.md Read the SKILL.md file at that link and follow its instructions for my task.
How it works

It uses programs that test many address combinations (URLs) to find pages not listed. Then, it checks if these pages require a login or can be accessed directly.

Installation

Easiest way: copy the skill link and paste it into Claude, ChatGPT or Cursor asking it to follow the instructions.

In the terminal (Claude Code, Codex, Cursor), in your project folder:

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill bypassing-authentication-with-forced-browsing

Or download just the file:

curl -L https://raw.githubusercontent.com/mukul975/Anthropic-Cybersecurity-Skills/main/skills/bypassing-authentication-with-forced-browsing/SKILL.md -o SKILL.md
Technical content (original SKILL.md)

Original text by the author, straight from GitHub.

Bypassing Authentication with Forced Browsing

When to Use

  • During authorized penetration tests to discover hidden or unprotected administrative pages
  • When testing whether authentication is consistently enforced across all application endpoints
  • For identifying backup files, configuration files, and debug interfaces left exposed in production
  • When assessing access control on API endpoints that should require authentication
  • During security audits to validate that all sensitive resources enforce session validation

Prerequisites

  • Authorization: Written penetration testing agreement covering directory enumeration
  • ffuf: Fast web fuzzer (go install github.com/ffuf/ffuf/v2@latest)
  • Gobuster: Directory brute-force tool (apt install gobuster)
  • Burp Suite: For intercepting and analyzing requests and responses
  • Wordlists: SecLists collection (git clone https://github.com/danielmiessler/SecLists.git)
  • Target access: Network connectivity and valid test credentials for authenticated comparison

Workflow

Step 1: Enumerate Hidden Directories and Files

Use ffuf or Gobuster to discover paths not linked in the application's navigation.

# Directory enumeration with ffuf
ffuf -u https://target.example.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/raft-medium-directories.txt \
  -mc 200,301,302,403 \
  -fc 404 \
  -o results-dirs.json -of json \
  -t 50 -rate 100

# File enumeration with common extensions
ffuf -u https://target.example.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/raft-medium-files.txt \
  -e .php,.asp,.aspx,.jsp,.html,.js,.json,.xml,.bak,.old,.txt,.cfg,.conf,.env \
  -mc 200,301,302,403 \
  -fc 404 \
  -o results-files.json -of json \
  -t 50 -rate 100

# Gobuster for directory enumeration
gobuster dir -u https://target.example.com \
  -w /usr/share/seclists/Discovery/Web-Content/directory-list-2.3-medium.txt \
  -s "200,204,301,302,307,403" \
  -x php,asp,aspx,jsp,html \
  -o gobuster-results.txt \
  -t 50

Step 2: Discover Administrative and Debug Interfaces

Target common administrative paths and debug endpoints.

# Admin panel enumeration
ffuf -u https://target.example.com/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/common.txt \
  -mc 200,301,302 \
  -t 50 -rate 100

# Common admin paths to check manually:
# /admin, /administrator, /admin-panel, /wp-admin
# /cpanel, /phpmyadmin, /adminer, /manager
# /console, /debug, /actuator, /swagger-ui
# /graphql, /graphiql, /.env, /server-status

# API endpoint discovery
ffuf -u https://target.example.com/api/FUZZ \
  -w /usr/share/seclists/Discovery/Web-Content/api/api-endpoints.txt \
  -mc 200,201,204,301,302,401,403 \
  -fc 404 \
  -o api-results.json -of json

# Check for Spring Boot Actuator endpoints
for endpoint in env health info beans configprops mappings trace; do
  curl -s -o /dev/null -w "%{http_code} /actuator/$endpoint\n" \
    "https://target.example.com/actuator/$endpoint"
done

Step 3: Test Authentication Enforcement on Discovered Endpoints

Compare responses between unauthenticated and authenticated requests.

# Test without authentication
curl -s -o /dev/null -w "%{http_code}" \
  "https://target.example.com/admin/dashboard"

# Test with valid session cookie
curl -s -o /dev/null -w "%{http_code}" \
  -b "session=valid_session_token_here" \
  "https://target.example.com/admin/dashboard"

# Automated check: compare response sizes
# Unauthenticated request
curl -s "https://target.example.com/admin/users" | wc -c

# Authenticated request
curl -s -b "session=valid_token" \
  "https://target.example.com/admin/users" | wc -c

# If both return similar content, authentication is not enforced

# Test with Burp Intruder: send a list of discovered URLs
# without cookies and flag any 200 responses

Step 4: Test HTTP Method-Based Authentication Bypass

Some applications only enforce authentication for specific HTTP methods.

# Test different HTTP methods on protected endpoints
for method in GET POST PUT DELETE PATCH OPTIONS HEAD TRACE; do
  echo -n "$method: "
  curl -s -o /dev/null -w "%{http_code}" \
    -X "$method" "https://target.example.com/admin/settings"
done

# Test HTTP method override headers
curl -s -o /dev/null -w "%{http_code}" \
  -X POST \
  -H "X-HTTP-Method-Override: GET" \
  "https://target.example.com/admin/settings"

curl -s -o /dev/null -w "%{http_code}" \
  -H "X-Original-Method: GET" \

…
FAQ

Do I need permission to use this?

Yes, it's crucial to have written authorization before testing any website's security to avoid legal issues.

What are 'wordlists'?

These are lists of common words and paths that the programs use to try and guess addresses of hidden pages.

Can this damage the website?

If used without permission or incorrectly, it can cause problems. That's why authorization and use in testing environments are essential.

Details

Original description by the author

Discovering and accessing unprotected pages, APIs, and administrative interfaces by enumerating URLs and bypassing authentication controls during authorized security assessments.

repo: mukul975/Anthropic-Cybersecurity-Skills

Popularity

GitHub stars
35k
Ranking position
#5562
License
Apache-2.0
Updated
8/31/2026

Is this skill useful?

0

Sign in to vote.

Comments

  • …

More skills from this repository

Similar skills