Sharp Edges

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...

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

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:

// 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:

# 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:

// 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:

// 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