Skip to main content
skill CX Codex

testing-mobile-api-authentication — Claude Code skill

The testing-mobile-api-authentication skill audits mobile API authentication and authorization, covering JWT, OAuth, token handling, sessions, IDOR, and privilege escalation.

Apache-2.0 276 installs ★ 36,511 updated 2026-08-31

Install into Claude Code · Skills CLI (Vercel) All methods and platforms ↓
npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill testing-mobile-api-authentication -a claude-code
Open on GitHub

What testing-mobile-api-authentication does

The skill guides an assessment of a mobile backend’s authentication surface. It maps login, registration, refresh, logout, password-reset, OTP, and profile endpoints, then examines JWT and opaque tokens. Its checks cover missing or invalid credentials, token reuse, session invalidation, object-level authorization, and horizontal privilege escalation.

It also covers OAuth 2.0 and OIDC mobile flows, including PKCE enforcement, redirect URI changes, and scope escalation. The listed toolkit includes Burp Suite or mitmproxy, Postman or curl, jwt.io or PyJWT, jwt_tool, hashcat, and the Autorize Burp Suite extension.

Use it only against APIs covered by explicit authorization. A test account is required, and SSL pinning must be bypassed when the target app uses it. Refresh-token rotation can invalidate the token during testing.

What it helps with

  • map mobile API authentication endpoints
  • inspect JWT signing and expiry handling
  • test missing, empty, expired, or reused tokens
  • check BOLA/IDOR and horizontal privilege escalation
  • review PKCE, redirect URI, and OAuth scope controls

Example prompts for the agent

  • Audit the mobile API authentication flow through Burp Suite and map its endpoints.
  • Analyze the test JWT with jwt.io or PyJWT, then check its algorithm, signature, and expiry handling.
  • Test BOLA/IDOR, logout invalidation, and OAuth 2.0 / OIDC PKCE using an authorized test account.

How to install testing-mobile-api-authentication

1Skills CLI (Vercel)

npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill testing-mobile-api-authentication -a claude-code

2Manually: put the files in place

~/.claude/skills/testing-mobile-api-authentication/SKILL.md

Copy the whole skill folder; for one project use .claude/skills/testing-mobile-api-authentication/

Step by step, with commands for each platform: How to install skills in Claude Code: five ways

Questions about testing-mobile-api-authentication

How do I install testing-mobile-api-authentication in Claude Code?

Run npx skills add mukul975/Anthropic-Cybersecurity-Skills --skill testing-mobile-api-authentication -a claude-code. Then check ~/.claude/skills/testing-mobile-api-authentication/SKILL.md.

What does testing-mobile-api-authentication do?

It guides security checks for mobile API authentication and authorization, including JWT handling, session controls, IDOR, privilege escalation, and OAuth flows.

What is required before using the skill?

Prepare Burp Suite or mitmproxy, valid test credentials, and Postman or curl. JWT work uses jwt.io or PyJWT, and SSL pinning must be bypassed when present.

Source text

SKILL.md · Apache-2.0
---
name: testing-mobile-api-authentication
description: 'Tests authentication and authorization mechanisms in mobile application
  APIs to identify broken authentication, insecure token management, session fixation,
  privilege escalation, and IDOR vulnerabilities. Use when performing API security
  assessments against mobile app backends, testing JWT implementations, evaluating
  OAuth flows, or assessing session management. Activates for requests involving mobile
  API auth testing, token security assessment, OAuth mobile flow testing, or API authorization
  bypass.

  '
domain: cybersecurity
subdomain: mobile-security
author: mahipal
tags:
- mobile-security
- android
- ios
- api-security
- authentication
- penetration-testing
version: 1.0.0
license: Apache-2.0
nist_csf:
- PR.PS-01
- PR.AA-05
- ID.RA-01
- DE.CM-09
mitre_attack:
- T1059
- T1056
- T1036
- T1078
- T1068
---
# Testing Mobile API Authentication

## When to Use

Use this skill when:
- Assessing mobile app backend API authentication during penetration tests
- Testing JWT token implementation for common vulnerabilities (none algorithm, weak signing)
- Evaluating OAuth 2.0 / OIDC flows in mobile applications for redirect, PKCE, and scope issues
- Testing for broken object-level authorization (BOLA/IDOR) in API endpoints

**Do not use** this skill against production APIs without explicit authorization and rate-limiting awareness.

## Prerequisites

- Burp Suite or mitmproxy configured as mobile device proxy
- SSL pinning bypassed on target application (if implemented)
- Valid test account credentials for the target application
- Postman or curl for API request crafting
- jwt.io or PyJWT for JWT analysis and manipulation

## Workflow

### Step 1: Map Authentication Endpoints

Intercept mobile app traffic to identify authentication-related endpoints:

```
POST /api/v1/auth/login          - Initial authentication
POST /api/v1/auth/register       - Account registration
POST /api/v1/auth/refresh        - Token refresh
POST /api/v1/auth/logout         - Session termination
POST /api/v1/auth/forgot-password - Password reset
POST /api/v1/auth/verify-otp     - OTP verification
GET  /api/v1/auth/me             - Authenticated user profile
```

### Step 2: Analyze Token Format and Security

**JWT Analysis:**
```bash
# Decode JWT without verification
echo "eyJhbGciOiJIUzI1NiIs..." | cut -d. -f2 | base64 -d 2>/dev/null

# Check for common JWT vulnerabilities:
# 1. None algorithm attack
# Change header to: {"alg":"none","typ":"JWT"}
# Remove signature: header.payload.

# 2. Algorithm confusion (RS256 to HS256)
# If server uses RS256, try HS256 with public key as secret

# 3. Weak signing key
# Use hashcat or jwt-cracker to brute-force HMAC secret
hashcat -m 16500 jwt.txt wordlist.txt

# 4. Expiration bypass
# Modify "exp" claim to future timestamp
```

**Opaque Token Analysis:**
```
- Test token length and entropy
- Check if tokens are sequential/predictable
- Test token reuse after logout
- Verify token invalidation on password change
```

### Step 3: Test Authentication Bypass

```bash
# Test missing authentication
curl -X GET https://api.target.com/api/v1/users/profile

# Test with empty/null token
curl -X GET https://api.target.com/api/v1/users/profile \
  -H "Authorization: Bearer "

curl -X GET https://api.target.com/api/v1/users/profile \
  -H "Authorization: Bearer null"

# Test with expired token (should fail)
curl -X GET https://api.target.com/api/v1/users/profile \
  -H "Authorization: Bearer <expired_token>"

# Test token from different user
curl -X GET https://api.target.com/api/v1/users/123/profile \
  -H "Authorization: Bearer <user_456_token>"
```

### Step 4: Test IDOR / Broken Object-Level Authorization

```bash
# Change user ID in request path
curl -X GET https://api.target.com/api/v1/users/123/orders \
  -H "Authorization: Bearer <user_456_token>"

# Change object ID in request body
curl -X PUT https://api.target.com/api/v1/orders/789 \
  -H "Authorization: Bearer <user_456_token>" \
  -d '{"status": "cancelled"}'

# Test horizontal privilege escalation
# Access admin endpoints with regular user token
curl -X GET https://api.target.com/api/v1/admin/users \
  -H "Authorization: Bearer <regular_user_token>"
```

### Step 5: Test Session Management

```bash
# Test concurrent sessions
# Login from multiple devices simultaneously - should both remain valid?

# Test session invalidation after logout
TOKEN=$(curl -s -X POST https://api.target.com/api/v1/auth/login \
  -d '{"email":"[email protected]","password":"pass"}' | jq -r '.token')

# Logout
curl -X POST https://api.target.com/api/v1/auth/logout \
  -H "Authorization: Bearer $TOKEN"

# Try using the same token (should fail)
curl -X GET https://api.target.com/api/v1/users/me \
  -H "Authorization: Bearer $TOKEN"

# Test session invalidation after password change
# Token obtained before password change should be invalidated
```

### Step 6: Test OAuth 2.0 / OIDC Mobile Flows

```bash
# Test for authorization code interception
# Check if PKCE (Proof Key for Code Exchange) is enforced
# Test with missing code_verifier parameter

# Test redirect URI manipulation
# Try custom scheme hijacking: myapp://callback
# Test with modified redirect_uri parameter

# Test scope escalation
# Request higher privileges than granted
```

## Key Concepts

| Term | Definition |
|------|-----------|
| **BOLA/IDOR** | Broken Object Level Authorization - accessing resources by changing identifiers without server-side authorization checks |
| **JWT** | JSON Web Token - self-contained authentication token with header, payload, and signature components |
| **PKCE** | Proof Key for Code Exchange - OAuth 2.0 extension preventing authorization code interception in mobile apps |
| **Token Refresh** | Mechanism for obtaining new access tokens using long-lived refresh tokens without re-authentication |
| **Session Fixation** | Attack where adversary sets a known session ID before victim authenticates, then hijacks the session |

## Tools & Systems

- **Burp Suite**: HTTP proxy for intercepting and modifying authentication requests
- **jwt_tool**: Python tool for testing JWT vulnerabilities (none algorithm, key confusion, claim manipulation)
- **Postman**: API testing client for crafting authentication requests
- **hashcat**: Password/JWT secret cracking tool for testing HMAC signing key strength
- **Autorize**: Burp Suite extension for automated authorization testing

## Common Pitfalls

- **Rate limiting masks issues**: API may rate-limit test requests. Use delays between requests and test from the tester's authorized perspective first.
- **Token in URL**: Some mobile APIs pass tokens in URL query parameters, exposing them in server logs and browser history. Flag as finding even if authorization works correctly.
- **Refresh token rotation**: Some APIs rotate refresh tokens on each use. If your test invalidates the refresh token, you may lock out your test account.
- **Mobile-specific OAuth**: Mobile apps use custom URI schemes for OAuth redirects, which can be intercepted by malicious apps registered for the same scheme.

© mahipal · Apache-2.0 · mukul975/Anthropic-Cybersecurity-Skills

Similar skills

All skills for Security →

From the same set152

The whole set →
auditing-terraform-infrastructure-for-security auditing-terraform-infrastructure-for-security guides AI assistants through auditing Terraform code with Checkov, tfsec, Terrascan, and OPA. Catches public access, lax IAM rules, and missing encryption before apply. CX Codex +1 279installs analyzing-typosquatting-domains-with-dnstwist analyzing-typosquatting-domains-with-dnstwist builds lookalike domain permutations for a name you own, resolves them, and scores the registered ones by page similarity and registration freshness. CX Codex +1 278installs analyzing-security-logs-with-splunk analyzing-security-logs-with-splunk investigates security incidents in Splunk using SPL queries. Correlates Windows events, Sysmon traces, proxy logs, and firewall traffic into a single timeline. CX Codex +1 278installs performing-ssrf-vulnerability-exploitation performing-ssrf-vulnerability-exploitation is a Claude Code skill that checks web app URL parameters for SSRF by probing cloud metadata, internal services, and protocol handlers during authorized penetration testing. CX Codex +1 277installs analyzing-threat-actor-ttps-with-mitre-navigator analyzing-threat-actor-ttps-with-mitre-navigator — a skill for mapping threat actor TTPs to the MITRE ATT&CK framework using the attackcti library and generating ATT&CK Navigator visualizations. CX Codex +1 275installs analyzing-prefetch-files-for-execution-history analyzing-prefetch-files-for-execution-history parses Windows Prefetch files to extract program execution timestamps and run counts. Built for forensic timeline reconstruction during incident response. CX Codex +1 275installs auditing-kubernetes-cluster-rbac auditing-kubernetes-cluster-rbac audits Kubernetes RBAC for excessive permissions, risky bindings, service account abuse, and privilege escalation paths. Useful for cluster access reviews. CX Codex +1 273installs exploiting-mass-assignment-in-rest-apis exploiting-mass-assignment-in-rest-apis guides testing and exploitation of mass assignment flaws in REST APIs. Useful for finding autobinding issues across ORM-backed endpoints. CX Codex +1 271installs

Project sponsors

Companies that keep this analytics open