@elizaos/skills 2.0.0-alpha.3

package/skills/sharp-edges/skills/sharp-edges/SKILL.md

@@ -0,0 +1,292 @@
+---
+name: sharp-edges
+description: "Identifies error-prone APIs, dangerous configurations, and footgun designs that enable security mistakes. Use when reviewing API designs, configuration schemas, cryptographic library ergonomics, or evaluating whether code follows 'secure by default' and 'pit of success' principles. Triggers: footgun, misuse-resistant, secure defaults, API usability, dangerous configuration."
+allowed-tools:
+  - Read
+  - Grep
+  - Glob
+---
+
+# Sharp Edges Analysis
+
+Evaluates whether APIs, configurations, and interfaces are resistant to developer misuse. Identifies designs where the "easy path" leads to insecurity.
+
+## When to Use
+
+- Reviewing API or library design decisions
+- Auditing configuration schemas for dangerous options
+- Evaluating cryptographic API ergonomics
+- Assessing authentication/authorization interfaces
+- Reviewing any code that exposes security-relevant choices to developers
+
+## When NOT to Use
+
+- Implementation bugs (use standard code review)
+- Business logic flaws (use domain-specific analysis)
+- Performance optimization (different concern)
+
+## Core Principle
+
+**The pit of success**: Secure usage should be the path of least resistance. If developers must understand cryptography, read documentation carefully, or remember special rules to avoid vulnerabilities, the API has failed.
+
+## Rationalizations to Reject
+
+| Rationalization | Why It's Wrong | Required Action |
+|-----------------|----------------|-----------------|
+| "It's documented" | Developers don't read docs under deadline pressure | Make the secure choice the default or only option |
+| "Advanced users need flexibility" | Flexibility creates footguns; most "advanced" usage is copy-paste | Provide safe high-level APIs; hide primitives |
+| "It's the developer's responsibility" | Blame-shifting; you designed the footgun | Remove the footgun or make it impossible to misuse |
+| "Nobody would actually do that" | Developers do everything imaginable under pressure | Assume maximum developer confusion |
+| "It's just a configuration option" | Config is code; wrong configs ship to production | Validate configs; reject dangerous combinations |
+| "We need backwards compatibility" | Insecure defaults can't be grandfather-claused | Deprecate loudly; force migration |
+
+## Sharp Edge Categories
+
+### 1. Algorithm/Mode Selection Footguns
+
+APIs that let developers choose algorithms invite choosing wrong ones.
+
+**The JWT Pattern** (canonical example):
+- Header specifies algorithm: attacker can set `"alg": "none"` to bypass signatures
+- Algorithm confusion: RSA public key used as HMAC secret when switching RS256→HS256
+- Root cause: Letting untrusted input control security-critical decisions
+
+**Detection patterns:**
+- Function parameters like `algorithm`, `mode`, `cipher`, `hash_type`
+- Enums/strings selecting cryptographic primitives
+- Configuration options for security mechanisms
+
+**Example - PHP password_hash allowing weak algorithms:**
+```php
+// DANGEROUS: allows crc32, md5, sha1
+password_hash($password, PASSWORD_DEFAULT); // Good - no choice
+hash($algorithm, $password); // BAD: accepts "crc32"
+```
+
+### 2. Dangerous Defaults
+
+Defaults that are insecure, or zero/empty values that disable security.
+
+**The OTP Lifetime Pattern:**
+```python
+# What happens when lifetime=0?
+def verify_otp(code, lifetime=300):  # 300 seconds default
+    if lifetime == 0:
+        return True  # OOPS: 0 means "accept all"?
+        # Or does it mean "expired immediately"?
+```
+
+**Detection patterns:**
+- Timeouts/lifetimes that accept 0 (infinite? immediate expiry?)
+- Empty strings that bypass checks
+- Null values that skip validation
+- Boolean defaults that disable security features
+- Negative values with undefined semantics
+
+**Questions to ask:**
+- What happens with `timeout=0`? `max_attempts=0`? `key=""`?
+- Is the default the most secure option?
+- Can any default value disable security entirely?
+
+### 3. Primitive vs. Semantic APIs
+
+APIs that expose raw bytes instead of meaningful types invite type confusion.
+
+**The Libsodium vs. Halite Pattern:**
+
+```php
+// Libsodium (primitives): bytes are bytes
+sodium_crypto_box($message, $nonce, $keypair);
+// Easy to: swap nonce/keypair, reuse nonces, use wrong key type
+
+// Halite (semantic): types enforce correct usage
+Crypto::seal($message, new EncryptionPublicKey($key));
+// Wrong key type = type error, not silent failure
+```
+
+**Detection patterns:**
+- Functions taking `bytes`, `string`, `[]byte` for distinct security concepts
+- Parameters that could be swapped without type errors
+- Same type used for keys, nonces, ciphertexts, signatures
+
+**The comparison footgun:**
+```go
+// Timing-safe comparison looks identical to unsafe
+if hmac == expected { }           // BAD: timing attack
+if hmac.Equal(mac, expected) { }  // Good: constant-time
+// Same types, different security properties
+```
+
+### 4. Configuration Cliffs
+
+One wrong setting creates catastrophic failure, with no warning.
+
+**Detection patterns:**
+- Boolean flags that disable security entirely
+- String configs that aren't validated
+- Combinations of settings that interact dangerously
+- Environment variables that override security settings
+- Constructor parameters with sensible defaults but no validation (callers can override with insecure values)
+
+**Examples:**
+```yaml
+# One typo = disaster
+verify_ssl: fasle  # Typo silently accepted as truthy?
+
+# Magic values
+session_timeout: -1  # Does this mean "never expire"?
+
+# Dangerous combinations accepted silently
+auth_required: true
+bypass_auth_for_health_checks: true
+health_check_path: "/"  # Oops
+```
+
+```php
+// Sensible default doesn't protect against bad callers
+public function __construct(
+    public string $hashAlgo = 'sha256',  // Good default...
+    public int $otpLifetime = 120,       // ...but accepts md5, 0, etc.
+) {}
+```
+
+See [config-patterns.md](references/config-patterns.md#unvalidated-constructor-parameters) for detailed patterns.
+
+### 5. Silent Failures
+
+Errors that don't surface, or success that masks failure.
+
+**Detection patterns:**
+- Functions returning booleans instead of throwing on security failures
+- Empty catch blocks around security operations
+- Default values substituted on parse errors
+- Verification functions that "succeed" on malformed input
+
+**Examples:**
+```python
+# Silent bypass
+def verify_signature(sig, data, key):
+    if not key:
+        return True  # No key = skip verification?!
+
+# Return value ignored
+signature.verify(data, sig)  # Throws on failure
+crypto.verify(data, sig)     # Returns False on failure
+# Developer forgets to check return value
+```
+
+### 6. Stringly-Typed Security
+
+Security-critical values as plain strings enable injection and confusion.
+
+**Detection patterns:**
+- SQL/commands built from string concatenation
+- Permissions as comma-separated strings
+- Roles/scopes as arbitrary strings instead of enums
+- URLs constructed by joining strings
+
+**The permission accumulation footgun:**
+```python
+permissions = "read,write"
+permissions += ",admin"  # Too easy to escalate
+
+# vs. type-safe
+permissions = {Permission.READ, Permission.WRITE}
+permissions.add(Permission.ADMIN)  # At least it's explicit
+```
+
+## Analysis Workflow
+
+### Phase 1: Surface Identification
+
+1. **Map security-relevant APIs**: authentication, authorization, cryptography, session management, input validation
+2. **Identify developer choice points**: Where can developers select algorithms, configure timeouts, choose modes?
+3. **Find configuration schemas**: Environment variables, config files, constructor parameters
+
+### Phase 2: Edge Case Probing
+
+For each choice point, ask:
+- **Zero/empty/null**: What happens with `0`, `""`, `null`, `[]`?
+- **Negative values**: What does `-1` mean? Infinite? Error?
+- **Type confusion**: Can different security concepts be swapped?
+- **Default values**: Is the default secure? Is it documented?
+- **Error paths**: What happens on invalid input? Silent acceptance?
+
+### Phase 3: Threat Modeling
+
+Consider three adversaries:
+
+1. **The Scoundrel**: Actively malicious developer or attacker controlling config
+   - Can they disable security via configuration?
+   - Can they downgrade algorithms?
+   - Can they inject malicious values?
+
+2. **The Lazy Developer**: Copy-pastes examples, skips documentation
+   - Will the first example they find be secure?
+   - Is the path of least resistance secure?
+   - Do error messages guide toward secure usage?
+
+3. **The Confused Developer**: Misunderstands the API
+   - Can they swap parameters without type errors?
+   - Can they use the wrong key/algorithm/mode by accident?
+   - Are failure modes obvious or silent?
+
+### Phase 4: Validate Findings
+
+For each identified sharp edge:
+
+1. **Reproduce the misuse**: Write minimal code demonstrating the footgun
+2. **Verify exploitability**: Does the misuse create a real vulnerability?
+3. **Check documentation**: Is the danger documented? (Documentation doesn't excuse bad design, but affects severity)
+4. **Test mitigations**: Can the API be used safely with reasonable effort?
+
+If a finding seems questionable, return to Phase 2 and probe more edge cases.
+
+## Severity Classification
+
+| Severity | Criteria | Examples |
+|----------|----------|----------|
+| Critical | Default or obvious usage is insecure | `verify: false` default; empty password allowed |
+| High | Easy misconfiguration breaks security | Algorithm parameter accepts "none" |
+| Medium | Unusual but possible misconfiguration | Negative timeout has unexpected meaning |
+| Low | Requires deliberate misuse | Obscure parameter combination |
+
+## References
+
+**By category:**
+
+- **Cryptographic APIs**: See [references/crypto-apis.md](references/crypto-apis.md)
+- **Configuration Patterns**: See [references/config-patterns.md](references/config-patterns.md)
+- **Authentication/Session**: See [references/auth-patterns.md](references/auth-patterns.md)
+- **Real-World Case Studies**: See [references/case-studies.md](references/case-studies.md) (OpenSSL, GMP, etc.)
+
+**By language** (general footguns, not crypto-specific):
+
+| Language | Guide |
+|----------|-------|
+| C/C++ | [references/lang-c.md](references/lang-c.md) |
+| Go | [references/lang-go.md](references/lang-go.md) |
+| Rust | [references/lang-rust.md](references/lang-rust.md) |
+| Swift | [references/lang-swift.md](references/lang-swift.md) |
+| Java | [references/lang-java.md](references/lang-java.md) |
+| Kotlin | [references/lang-kotlin.md](references/lang-kotlin.md) |
+| C# | [references/lang-csharp.md](references/lang-csharp.md) |
+| PHP | [references/lang-php.md](references/lang-php.md) |
+| JavaScript/TypeScript | [references/lang-javascript.md](references/lang-javascript.md) |
+| Python | [references/lang-python.md](references/lang-python.md) |
+| Ruby | [references/lang-ruby.md](references/lang-ruby.md) |
+
+See also [references/language-specific.md](references/language-specific.md) for a combined quick reference.
+
+## Quality Checklist
+
+Before concluding analysis:
+
+- [ ] Probed all zero/empty/null edge cases
+- [ ] Verified defaults are secure
+- [ ] Checked for algorithm/mode selection footguns
+- [ ] Tested type confusion between security concepts
+- [ ] Considered all three adversary types
+- [ ] Verified error paths don't bypass security
+- [ ] Checked configuration validation
+- [ ] Constructor params validated (not just defaulted) - see [config-patterns.md](references/config-patterns.md#unvalidated-constructor-parameters)

package/skills/sharp-edges/skills/sharp-edges/references/auth-patterns.md

@@ -0,0 +1,252 @@
+# Authentication & Session Footguns
+
+Patterns that make authentication and session management error-prone.
+
+## Password Handling
+
+### Comparison Vulnerabilities
+
+```python
+# DANGEROUS: Short-circuit evaluation
+def check_password(user_input, stored):
+    return user_input == stored  # Timing attack
+
+# DANGEROUS: Empty password bypass
+def check_password(user_input, stored):
+    if not stored:
+        return True  # No password set = access granted?
+    return constant_time_compare(user_input, stored)
+
+# DANGEROUS: Null bypass
+def authenticate(username, password):
+    user = get_user(username)
+    if user is None:
+        return None  # No user = return None
+    if password == user.password:  # None == None if both None
+        return user
+```
+
+### Length Limits That Truncate
+
+```python
+# DANGEROUS: Password truncated before hashing
+def hash_password(password: str) -> str:
+    password = password[:72]  # bcrypt limit
+    return bcrypt.hash(password)
+
+# User sets: "password123" + 64 more characters + "IMPORTANT_ENTROPY"
+# Stored: hash of just "password123" + first 61 characters
+# Attacker only needs to brute force truncated version
+```
+
+**Fix**: Reject passwords over limit; don't silently truncate.
+
+### Validation Ordering
+
+```python
+# DANGEROUS: Username enumeration
+def login(username, password):
+    user = db.get_user(username)
+    if not user:
+        return "User not found"  # Reveals user doesn't exist
+    if not verify_password(password, user.password_hash):
+        return "Wrong password"  # Reveals user DOES exist
+    return create_session(user)
+
+# SECURE: Uniform error
+def login(username, password):
+    user = db.get_user(username)
+    if not user or not verify_password(password, user.password_hash):
+        return "Invalid credentials"
+    return create_session(user)
+```
+
+## Session Management
+
+### Session Fixation Enablers
+
+```python
+# DANGEROUS: Session ID accepted from request
+def login(request):
+    session_id = request.cookies.get("session") or generate_session_id()
+    # Attacker gives victim a known session ID before login
+    # After login, attacker knows victim's session
+    sessions[session_id] = user
+```
+
+**Fix**: Always generate new session ID on authentication state change.
+
+### Token Generation Weakness
+
+```python
+# DANGEROUS: Predictable tokens
+import time
+session_id = hashlib.md5(str(time.time()).encode()).hexdigest()
+# Attacker knows approximate login time = can guess session
+
+# DANGEROUS: Insufficient entropy
+session_id = ''.join(random.choice('abcdef') for _ in range(8))
+# Only 6^8 = 1.6M possibilities
+
+# SECURE: Cryptographic randomness
+session_id = secrets.token_urlsafe(32)
+```
+
+### Session Timeout Footguns
+
+```python
+# DANGEROUS: Timeout of 0 means "never"?
+class SessionConfig:
+    timeout_seconds: int = 3600  # 1 hour
+    # What if someone sets 0? Infinite session?
+
+# DANGEROUS: Negative timeout
+if current_time - session_created > timeout:
+    # If timeout is negative, this is always False
+    # Session never expires
+```
+
+## Token/OTP Handling
+
+### OTP Lifetime Issues
+
+```python
+# DANGEROUS: lifetime=0 accepts all
+def verify_otp(code, user, lifetime=300):
+    if lifetime == 0:
+        return True  # Skip expiry check entirely
+
+# DANGEROUS: Negative lifetime
+    if otp.created_at + lifetime > current_time:
+        return True
+    # If lifetime is negative, always expired? Or underflow?
+
+# DANGEROUS: No rate limiting
+def verify_otp(code, user):
+    return code == user.current_otp
+    # Attacker can try all 1,000,000 6-digit codes
+```
+
+### Token Reuse
+
+```python
+# DANGEROUS: OTP valid until next OTP generated
+def verify_otp(code, user):
+    return code == user.otp
+
+# DANGEROUS: Reset token valid forever
+def verify_reset_token(token):
+    return token in valid_tokens
+    # Never expires, never invalidated on use
+
+# SECURE: Single-use, time-limited
+def verify_reset_token(token):
+    record = db.get_token(token)
+    if not record:
+        return False
+    if record.used or record.expired:
+        return False
+    record.mark_used()  # Invalidate immediately
+    return True
+```
+
+## Authorization Footguns
+
+### Role/Permission Accumulation
+
+```python
+# DANGEROUS: String-based permissions
+user.permissions = "read,write"
+user.permissions += ",admin"  # Too easy
+
+# DANGEROUS: Any-match logic
+def has_permission(user, required):
+    return any(p in user.permissions for p in required.split(","))
+# has_permission(user, "admin,readonly") - matches if ANY is present
+
+# DANGEROUS: Substring matching
+if "admin" in user.role:
+    grant_admin_access()
+# "readonly_admin_viewer" contains "admin"
+```
+
+### Missing Authorization Checks
+
+```python
+# DANGEROUS: Auth check in one place, not others
+@require_login
+def list_documents(request):
+    return Document.objects.all()
+
+def get_document(request, doc_id):
+    # Developer forgot @require_login
+    return Document.objects.get(id=doc_id)
+
+def delete_document(request, doc_id):
+    # Developer also forgot authorization check
+    Document.objects.get(id=doc_id).delete()
+```
+
+**Fix**: Centralized authorization; deny-by-default.
+
+### IDOR Enablers
+
+```python
+# DANGEROUS: User ID from request
+def get_profile(request):
+    user_id = request.GET["user_id"]  # Attacker changes this
+    return User.objects.get(id=user_id)
+
+# DANGEROUS: Sequential IDs
+user = User.objects.create(...)  # Gets ID 12345
+# Attacker tries 12344, 12346, etc.
+```
+
+## Multi-Factor Authentication
+
+### Bypassable MFA
+
+```python
+# DANGEROUS: MFA check in frontend only
+# API directly accessible without MFA
+
+# DANGEROUS: "Remember this device" with weak token
+device_token = hashlib.md5(user_agent.encode()).hexdigest()
+# Attacker spoofs User-Agent to bypass MFA
+
+# DANGEROUS: MFA disabled by user preference
+if user.preferences.get("mfa_enabled", True):
+    require_mfa()
+# Preference stored in same session = attacker disables it
+```
+
+### Recovery Code Issues
+
+```python
+# DANGEROUS: Predictable recovery codes
+recovery_code = str(user.id).zfill(8)  # Just the user ID
+
+# DANGEROUS: Unlimited recovery attempts
+for _ in range(1000000):
+    try_recovery_code(guess)
+
+# DANGEROUS: Recovery codes don't invalidate
+if code in user.recovery_codes:
+    login(user)
+    # Code still valid for reuse
+```
+
+## Auth API Design Checklist
+
+For authentication APIs, verify:
+
+- [ ] **Constant-time comparison**: Password/token checks use constant-time compare
+- [ ] **Empty value rejection**: Empty passwords/tokens explicitly rejected
+- [ ] **Uniform errors**: No user enumeration via different error messages
+- [ ] **Session regeneration**: New session ID on auth state changes
+- [ ] **Cryptographic tokens**: secrets module, not random or time-based
+- [ ] **Positive timeouts**: Zero/negative values rejected or have safe meaning
+- [ ] **Single-use tokens**: OTPs/reset tokens invalidated on use
+- [ ] **Rate limiting**: Brute force protection on all auth endpoints
+- [ ] **Authorization centralized**: Not scattered across endpoints
+- [ ] **MFA in backend**: Not bypassable by skipping frontend