Skills

Skills are knowledge packages that inject specialized security expertise into agent context. Each skill provides advanced testing techniques, practical examples, and validation methods for specific vulnerability types, technologies, or frameworks.

Overview

From the skills documentation:

Skills are specialized knowledge packages that enhance Strix agents with deep expertise in specific vulnerability types, technologies, and testing methodologies. Each skill provides advanced techniques, practical examples, and validation methods that go beyond baseline security knowledge.

Agents can load up to 5 skills at creation time, selecting the most relevant ones for their specific task.

How Skills Work

Dynamic Injection

When an agent is created, skills are loaded and injected into the system prompt:

# From strix/skills/__init__.py
def load_skills(skill_names: list[str]) -> dict[str, str]:
    skill_content = {}
    skills_dir = get_strix_resource_path("skills")
    
    for skill_name in skill_names:
        # Find skill file in categories
        for category, skills in all_categories.items():
            if skill_name in skills:
                skill_path = f"{category}/{skill_name}.md"
                break
        
        # Load and strip frontmatter
        content = full_path.read_text(encoding="utf-8")
        content = _FRONTMATTER_PATTERN.sub("", content).lstrip()
        skill_content[skill_name] = content
    
    return skill_content

Agent Creation with Skills

# From strix/tools/agents_graph/agents_graph_actions.py
create_agent(
    task="Test JWT authentication for token forgery and algorithm confusion",
    name="JWT Security Specialist",
    skills="authentication_jwt,business_logic"  # Comma-separated
)

The LLM configuration includes the loaded skills:

# From strix/agents/StrixAgent/strix_agent.py
self.default_llm_config = LLMConfig(skills=default_skills)

Skills are not additional tools. They’re knowledge injected into the agent’s system prompt to guide reasoning and testing strategies.

Skill Categories

Skills are organized by domain:

Vulnerabilities

Path: strix/skills/vulnerabilities/ Core vulnerability classes for web applications and APIs:

Authentication & Authorization

authentication_jwt - JWT/OIDC security testing, algorithm confusion, token forgery
broken_function_level_authorization - Vertical privilege escalation, role bypasses
idor - Insecure Direct Object References, horizontal privilege escalation
mass_assignment - Parameter pollution, unintended field updates

Injection Attacks

sql_injection - SQLi detection, exploitation, and validation
xss - Cross-Site Scripting (reflected, stored, DOM-based)
xxe - XML External Entity attacks
rce - Remote Code Execution vulnerabilities
ssrf - Server-Side Request Forgery
path_traversal_lfi_rfi - File path attacks, Local/Remote File Inclusion

Business Logic & Data

business_logic - Application logic flaws, race conditions, state manipulation
race_conditions - TOCTOU, parallel request attacks
information_disclosure - Sensitive data exposure, verbose errors
insecure_file_uploads - File upload bypasses, malicious content

Web-Specific

csrf - Cross-Site Request Forgery
open_redirect - Unvalidated redirects
subdomain_takeover - DNS and hosting misconfigurations

Available skills:

$ ls strix/skills/vulnerabilities/
authentication_jwt.md
broken_function_level_authorization.md
business_logic.md
csrf.md
idor.md
information_disclosure.md
insecure_file_uploads.md
mass_assignment.md
open_redirect.md
path_traversal_lfi_rfi.md
race_conditions.md
rce.md
sql_injection.md
ssrf.md
subdomain_takeover.md
xss.md
xxe.md

Frameworks

Path: strix/skills/frameworks/ Framework-specific testing techniques:

fastapi - FastAPI security patterns, Pydantic bypasses, async vulnerabilities
nextjs - Next.js API routes, SSR/SSG security, middleware bypasses

Use case:

create_agent(
    task="Analyze Next.js application for security vulnerabilities",
    name="Next.js Security Auditor",
    skills="nextjs,xss,csrf,authentication_jwt"
)

Technologies

Path: strix/skills/technologies/ Third-party service and platform-specific knowledge:

Authentication providers (Auth0, Firebase, Supabase)
Payment gateways (Stripe, PayPal)
Cloud services (AWS, Azure, GCP)
Databases and storage systems

Protocols

Path: strix/skills/protocols/ Protocol-specific testing patterns:

graphql - GraphQL introspection, batching attacks, depth limits
websocket - WebSocket security, message injection
oauth - OAuth2 flows, PKCE, redirect_uri validation
grpc - gRPC reflection, metadata manipulation

Cloud

Path: strix/skills/cloud/ Cloud provider security testing:

aws - AWS-specific misconfigurations, IAM issues
azure - Azure security, Managed Identity exploitation
gcp - GCP metadata service, service account abuse
kubernetes - K8s API security, pod escapes

Reconnaissance

Path: strix/skills/reconnaissance/ Advanced information gathering:

Subdomain enumeration techniques
Technology fingerprinting
API discovery methods
Attack surface mapping

Custom

Path: strix/skills/custom/ Community-contributed and specialized skills for:

Industry-specific testing (healthcare, finance, IoT)
Regional compliance requirements
Proprietary technology stacks

Skill Structure

Anatomy of a Skill

Let’s examine the JWT authentication skill:

---
name: authentication-jwt
description: JWT and OIDC security testing covering token forgery, algorithm confusion, and claim manipulation
---

# Authentication / JWT / OIDC

JWT/OIDC failures often enable token forgery, token confusion, cross-service acceptance, and durable account takeover.

## Attack Surface

- Web/mobile/API authentication using JWT (JWS/JWE) and OIDC/OAuth2
- Access vs ID tokens, refresh tokens, device/PKCE/Backchannel flows
- First-party and microservices verification, gateways, and JWKS distribution

## Reconnaissance

### Endpoints

- Well-known: `/.well-known/openid-configuration`, `/oauth2/.well-known/openid-configuration`
- Keys: `/jwks.json`, rotating key endpoints, tenant-specific JWKS
- Auth: `/authorize`, `/token`, `/introspect`, `/revoke`, `/logout`

### Token Features

- Headers: `{"alg":"RS256","kid":"...","typ":"JWT","jku":"...","x5u":"..."}`
- Claims: `{"iss":"...","aud":"...","sub":"user","scope":"...","exp":...}`

## Key Vulnerabilities

### Signature Verification

- **RS256→HS256 confusion**: Change alg to HS256 and use RSA public key as HMAC secret
- **"none" algorithm**: Set `"alg":"none"` and drop signature if libraries accept it
- **ECDSA malleability**: Weak verification accepting non-canonical signatures

### Header Manipulation

- **kid injection**: Path traversal `../../../../keys/prod.key`, SQL/command injection
- **jku/x5u abuse**: Host attacker-controlled JWKS/X509; if not pinned, server fetches attacker keys
- **jwk header injection**: Embed attacker JWK in header

### Claims Validation Gaps

- **iss/aud/azp not enforced**: Cross-service token reuse
- **scope/roles fully trusted**: Privilege inflation via claim edits
- **exp/nbf/iat not enforced**: Accept expired tokens

## Advanced Techniques

### Microservices and Gateways

- Audience mismatch: Services verify signature but ignore aud
- Header trust: Gateway injects X-User-Id, backend trusts it over token

### JWS Edge Cases

- Unencoded payload (b64=false) with crit header
- Nested JWT verification order errors

Each skill provides:

Frontmatter metadata: Name and description
Attack surface: Where vulnerabilities commonly appear
Reconnaissance: How to discover potential issues
Key vulnerabilities: Specific weaknesses to test for
Advanced techniques: Non-obvious attack vectors
Special contexts: Platform or environment-specific considerations

Best Practices for Skills

A good skill should: ✅ Focus on actionable techniques - Not just theory, but specific testing methods ✅ Include practical examples - Real payloads, commands, and test cases ✅ Provide validation methods - How to confirm findings and avoid false positives ✅ Cover edge cases - Non-obvious scenarios and configuration-dependent behavior ✅ Be concise - Focus on high-value information, avoid redundancy

Skill Selection Strategy

Automatic Selection

The root agent analyzes the target and automatically creates sub-agents with relevant skills:

# Root agent reasoning:
# "Target is a REST API with JWT authentication"
# "I should create a specialized agent for JWT testing"

create_agent(
    task="Analyze JWT implementation for security vulnerabilities",
    name="JWT Security Specialist",
    skills="authentication_jwt,broken_function_level_authorization"
)

Manual Selection

You can guide skill selection through instructions:

strix scan \
  --target https://api.example.com \
  --instructions "Focus on GraphQL-specific vulnerabilities including batching attacks and introspection abuse"

The agent will prioritize the graphql skill and related vulnerability skills.

Skill Limits

Agents can load maximum 5 skills to balance:

Context window size: More skills = larger prompts
Focus: Too many skills dilute attention
Relevance: Each skill should apply to the task

# Good: Focused selection
skills="authentication_jwt,idor,business_logic"

# Bad: Unfocused, wasted skill slots
skills="xss,sql_injection,csrf,xxe,ssrf"  # Too broad for one agent

Choose skills that complement each other and are relevant to the specific task. Generic collections of unrelated skills reduce effectiveness.

Skill Discovery

List available skills:

# From strix/skills/__init__.py
from strix.skills import get_available_skills

available = get_available_skills()
for category, skills in available.items():
    print(f"{category}: {', '.join(skills)}")

Validate skill names:

from strix.skills import validate_skill_names

result = validate_skill_names([
    "authentication_jwt",
    "graphql",
    "nonexistent_skill"
])

print(result["valid"])    # ["authentication_jwt", "graphql"]
print(result["invalid"])  # ["nonexistent_skill"]

Creating Custom Skills

Skill Template

Create a new skill file in ~/.strix/skills/custom/:

---
name: my-custom-skill
description: Brief description of what this skill covers
---

# Skill Title

Introduction explaining the security domain.

## Attack Surface

Where these vulnerabilities commonly appear:
- Component A
- Feature B
- Integration C

## Reconnaissance

How to discover potential issues:

### Discovery Methods

- Check for indicator X
- Look for pattern Y
- Analyze behavior Z

### Common Endpoints

- `/api/endpoint1`
- `/admin/endpoint2`

## Key Vulnerabilities

### Vulnerability Class 1

Description of the vulnerability.

**Testing approach:**

1. Step one
2. Step two
3. Step three

**Example payload:**

```http
POST /api/endpoint HTTP/1.1
Host: example.com
Content-Type: application/json

{"param": "malicious_value"}

Vulnerability Class 2

…

Advanced Techniques

Non-obvious attack vectors and edge cases.

Special Contexts

Platform-specific considerations:

Mobile Applications

Mobile-specific attack surfaces

Microservices

Service mesh security considerations

### Registering Custom Skills

Custom skills are automatically discovered from:

1. `~/.strix/skills/custom/` (user-level)
2. `./strix_skills/` (project-level)

Use them like built-in skills:

```python
create_agent(
    task="Test custom authentication system",
    name="Custom Auth Tester",
    skills="my-custom-skill,authentication_jwt"
)

Skill Examples

Combining Skills Effectively

API Testing:

skills="authentication_jwt,broken_function_level_authorization,idor,mass_assignment"

GraphQL Security:

skills="graphql,idor,broken_function_level_authorization,information_disclosure"

Cloud Application:

skills="aws,ssrf,information_disclosure,rce"

Web Application:

skills="xss,csrf,sql_injection,business_logic"

Skill Inheritance

Sub-agents don’t inherit parent skills:

# Parent has skills: ["authentication_jwt", "idor"]

# Sub-agent gets its own skills based on task
create_agent(
    task="Test file upload functionality",
    name="Upload Security Tester",
    skills="insecure_file_uploads,path_traversal_lfi_rfi,rce"  # Different from parent
)

Internal Skills

Some skills are used internally by Strix:

Scan Modes

Path: strix/skills/scan_modes/ Define high-level testing strategies:

quick - Fast vulnerability discovery
thorough - Comprehensive testing
stealth - Low-noise testing

Coordination

Path: strix/skills/coordination/ Multi-agent orchestration patterns:

root_agent - Loaded by root agents for coordination strategies

Internal skills are excluded from user-facing skill selection but are automatically applied when appropriate.

Contributing Skills

Share your skills with the community:

Create skill file following the structure above
Test thoroughly with real applications
Submit pull request to Strix repository
Document use cases in the PR description

Contribution Guidelines

Accuracy: Techniques must be practical and effective
Completeness: Cover attack surface, reconnaissance, and exploitation
Examples: Include working payloads and commands
Validation: Explain how to confirm findings
Originality: Add value beyond existing skills

Skill Limitations

Not a Replacement for Tools

Skills provide knowledge, not capabilities. Agents still need appropriate tools:

# Skill provides knowledge about SQLi
skills="sql_injection"

# But agent needs terminal tool to run sqlmap
terminal_execute(command="sqlmap -u https://example.com/?id=1 --batch")

Context Window Constraints

More skills = larger prompts = higher costs and latency:

Each skill adds ~1-5K tokens
5 skills can add 5-25K tokens
Monitor LLM costs if using many skills

Specificity vs. Generalization

Skills should be:

Specific enough to provide actionable techniques
General enough to apply across multiple targets

Avoid:

Overly generic skills that duplicate baseline knowledge
Hyper-specific skills that only apply to one application

Next Steps

Agents

Learn how agents use skills

Tools

Explore available tools

Vulnerability Detection

See skills in action

Contributing

Create and share your own skills

Get Started

Core Concepts

Usage

Integrations

Configuration

Documentation Index

​Overview

​How Skills Work

​Dynamic Injection

​Agent Creation with Skills

​Skill Categories

​Vulnerabilities

​Frameworks

​Technologies

​Protocols

​Cloud

​Reconnaissance

​Custom

​Skill Structure

​Anatomy of a Skill

​Best Practices for Skills

​Skill Selection Strategy

​Automatic Selection

​Manual Selection

​Skill Limits

​Skill Discovery

​Creating Custom Skills

​Skill Template

​Vulnerability Class 2

​Advanced Techniques

​Special Contexts

​Mobile Applications

​Microservices

​Skill Examples

​Combining Skills Effectively

​Skill Inheritance

​Internal Skills

​Scan Modes

​Coordination

​Contributing Skills

​Contribution Guidelines

​Skill Limitations

​Not a Replacement for Tools

​Context Window Constraints

​Specificity vs. Generalization

​Next Steps

Agents

Tools

Vulnerability Detection

Contributing

Build docs developers (and LLMs) love

Overview

How Skills Work

Dynamic Injection

Agent Creation with Skills

Skill Categories

Vulnerabilities

Frameworks

Technologies

Protocols

Cloud

Reconnaissance

Custom

Skill Structure

Anatomy of a Skill

Best Practices for Skills

Skill Selection Strategy

Automatic Selection

Manual Selection

Skill Limits

Skill Discovery

Creating Custom Skills

Skill Template

Vulnerability Class 2

Advanced Techniques

Special Contexts

Mobile Applications

Microservices

Skill Examples

Combining Skills Effectively

Skill Inheritance

Internal Skills

Scan Modes

Coordination

Contributing Skills

Contribution Guidelines

Skill Limitations

Not a Replacement for Tools

Context Window Constraints

Specificity vs. Generalization

Next Steps