Perseus Crypto

Perseus Crypto Specialist

Context & Authorization

IMPORTANT: This skill performs cryptographic security analysis on the user's own codebase. This is defensive security testing to find crypto weaknesses before they lead to data breaches.

Authorization: The user owns this codebase and has explicitly requested this specialized analysis.

Multi-Language Support

Overview

This specialist skill performs comprehensive cryptographic analysis including JWT security, hashing, encryption, and key management across all major languages.

When to Use: After /scan identifies JWT usage, password hashing, encryption, or secrets handling.

Goal: Ensure cryptographic implementations follow security best practices.

Engagement Mode Compatibility

Safety Gates (Required)

1. Read deliverables/engagement_profile.md before any runtime validation.
2. Default to PRODUCTION_SAFE if mode is unspecified.
3. Enforce kill-switch thresholds from engagement profile.
4. Never expose real secrets, keys, or live credentials in outputs.

Cryptographic Issues Covered

Execution Instructions

Step 0: Mode & Scope Alignment

• Load mode/scope/limits from deliverables/engagement_profile.md.
• Respect deliverables/verification_scope.md when present.
• Keep production checks passive-first and evidence-based.

Phase 1: JWT Analysis (4 Parallel Agents)

1. JWT Algorithm Analyst:

   • "Find all JWT verification code. Check for algorithm validation."

   Language-Specific Patterns:

   javascriptCopy code
   // Node.js - VULNERABLE
   jwt.verify(token, secret);  // Accepts any algorithm
   
   // Node.js - SAFE
   jwt.verify(token, secret, { algorithms: ['HS256'] });
   

   goCopy code
   // Go - VULNERABLE
   token, _ := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
       return secret, nil  // No algorithm check!
   })
   
   // Go - SAFE
   token, _ := jwt.Parse(tokenString, func(t *jwt.Token) (interface{}, error) {
       if _, ok := t.Method.(*jwt.SigningMethodHMAC); !ok {
           return nil, fmt.Errorf("unexpected method: %v", t.Header["alg"])
       }
       return secret, nil
   })
   

   pythonCopy code
   # Python - VULNERABLE
   jwt.decode(token, secret)  # Accepts any algorithm
   
   # Python - SAFE
   jwt.decode(token, secret, algorithms=['HS256'])
   

   phpCopy code
   // PHP - VULNERABLE
   JWT::decode($token, $key);  // Check library defaults
   
   // PHP - SAFE
   JWT::decode($token, new Key($key, 'HS256'));
   

   rustCopy code
   // Rust - SAFE (explicit by design)
   decode::<Claims>(&token, &DecodingKey::from_secret(secret), &Validation::new(Algorithm::HS256))
   

2. JWT Secret Analyst:

   • "Find JWT signing secrets across languages."

   Patterns:

   javascriptCopy code
   // VULNERABLE - Weak secret
   const secret = 'secret123';
   const secret = 'password';
   
   // VULNERABLE - Hardcoded
   jwt.sign(payload, 'my-super-secret-key');
   
   // SAFE - From environment, strong
   const secret = process.env.JWT_SECRET;  // Must be 32+ chars
   

   goCopy code
   // VULNERABLE
   var jwtSecret = []byte("weak-secret")
   
   // SAFE
   var jwtSecret = []byte(os.Getenv("JWT_SECRET"))
   

   pythonCopy code
   # VULNERABLE
   SECRET_KEY = "secret"
   
   # SAFE
   SECRET_KEY = os.environ.get("JWT_SECRET")
   

3. JWT Claims Analyst:

   • "Analyze JWT claim validation."

   Required Validations:

   Claim	Purpose	Check
   exp	Expiration	Token not expired
   iat	Issued At	Not issued in future
   nbf	Not Before	Token is active
   iss	Issuer	Trusted issuer
   aud	Audience	Intended recipient

4. JWT Key Management Analyst:

   • "Check RS256/ES256 key handling."

   Issues:

   • Private key in repository
   • Key without rotation
   • Public key as HMAC secret (algorithm confusion)

Phase 2: Password Hashing Analysis (3 Parallel Agents)

1. Hash Algorithm Analyst:

   • "Find all password hashing across languages."

   Language-Specific Patterns:

   javascriptCopy code
   // Node.js - VULNERABLE
   crypto.createHash('md5').update(password).digest('hex');
   crypto.createHash('sha1').update(password).digest('hex');
   crypto.createHash('sha256').update(password).digest('hex');  // No salt!
   
   // Node.js - SAFE
   await bcrypt.hash(password, 12);
   await argon2.hash(password);
   

   goCopy code
   // Go - VULNERABLE
   md5.Sum([]byte(password))
   sha256.Sum256([]byte(password))
   
   // Go - SAFE
   bcrypt.GenerateFromPassword([]byte(password), bcrypt.DefaultCost)
   argon2.IDKey([]byte(password), salt, 1, 64*1024, 4, 32)
   

   pythonCopy code
   # Python - VULNERABLE
   hashlib.md5(password.encode()).hexdigest()
   hashlib.sha256(password.encode()).hexdigest()
   
   # Python - SAFE
   bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))
   from passlib.hash import argon2
   argon2.hash(password)
   

   phpCopy code
   // PHP - VULNERABLE
   md5($password);
   sha1($password);
   hash('sha256', $password);
   
   // PHP - SAFE
   password_hash($password, PASSWORD_ARGON2ID);
   password_hash($password, PASSWORD_BCRYPT, ['cost' => 12]);
   

   rustCopy code
   // Rust - SAFE
   bcrypt::hash(password, bcrypt::DEFAULT_COST)?;
   argon2::hash_encoded(password.as_bytes(), &salt, &config)?;
   

   javaCopy code
   // Java - VULNERABLE
   MessageDigest.getInstance("MD5").digest(password.getBytes());
   
   // Java - SAFE
   BCrypt.hashpw(password, BCrypt.gensalt(12));
   

2. Hash Comparison Analyst:

   • "Check for timing-safe comparison."

   Patterns:

   javascriptCopy code
   // VULNERABLE - Timing attack
   if (storedHash === computedHash) { ... }
   
   // SAFE
   crypto.timingSafeEqual(Buffer.from(storedHash), Buffer.from(computedHash))
   

   goCopy code
   // VULNERABLE
   if storedHash == computedHash { ... }
   
   // SAFE
   subtle.ConstantTimeCompare([]byte(storedHash), []byte(computedHash))
   

   pythonCopy code
   # VULNERABLE
   if stored_hash == computed_hash: ...
   
   # SAFE
   hmac.compare_digest(stored_hash, computed_hash)
   

3. Password Policy Analyst:

   • "Check password strength enforcement."

Phase 3: Encryption Analysis (4 Parallel Agents)

1. Cipher Selection Analyst:

   • "Find all encryption operations."

   Vulnerable Ciphers:

   Cipher	Status	Use Instead
   DES	Broken	AES-256-GCM
   3DES	Deprecated	AES-256-GCM
   RC4	Broken	AES-256-GCM
   Blowfish	Weak	AES-256-GCM
   AES-ECB	Insecure	AES-256-GCM
   AES-CBC	OK (with HMAC)	AES-256-GCM preferred

   Language Patterns:

   javascriptCopy code
   // Node.js - VULNERABLE
   crypto.createCipher('des', key);
   crypto.createCipheriv('aes-128-ecb', key, '');
   
   // Node.js - SAFE
   crypto.createCipheriv('aes-256-gcm', key, iv);
   

   goCopy code
   // Go - VULNERABLE
   des.NewCipher(key)
   cipher.NewCBCEncrypter(block, iv)  // Without HMAC
   
   // Go - SAFE
   cipher.NewGCM(block)
   

   pythonCopy code
   # Python - VULNERABLE
   from Crypto.Cipher import DES
   cipher = AES.new(key, AES.MODE_ECB)
   
   # Python - SAFE
   cipher = AES.new(key, AES.MODE_GCM, nonce=nonce)
   

2. IV/Nonce Analyst:

   • "Check IV/nonce generation."

   Issues:

   javascriptCopy code
   // VULNERABLE - Static IV
   const iv = Buffer.from('0000000000000000', 'hex');
   
   // VULNERABLE - Predictable
   const iv = Buffer.from(Date.now().toString());
   
   // SAFE - Random
   const iv = crypto.randomBytes(16);
   

3. Key Derivation Analyst:

   • "Check key derivation from passwords."

   Patterns:

   javascriptCopy code
   // VULNERABLE - Direct use
   const key = Buffer.from(password);
   
   // SAFE - PBKDF2
   crypto.pbkdf2Sync(password, salt, 100000, 32, 'sha256');
   
   // SAFE - scrypt
   crypto.scryptSync(password, salt, 32);
   

4. Key Management Analyst:

   • "Find encryption key storage issues."

Phase 4: Random Number Analysis (2 Parallel Agents)

1. PRNG Analyst:

   • "Find insecure random number generation."

   Language-Specific:

   javascriptCopy code
   // VULNERABLE
   Math.random()
   
   // SAFE
   crypto.randomBytes(32)
   crypto.randomUUID()
   

   goCopy code
   // VULNERABLE
   math/rand.Int()
   
   // SAFE
   crypto/rand.Read(buf)
   

   pythonCopy code
   # VULNERABLE
   random.random()
   random.randint()
   
   # SAFE
   secrets.token_bytes(32)
   secrets.token_hex(32)
   secrets.token_urlsafe(32)
   

   phpCopy code
   // VULNERABLE
   rand()
   mt_rand()
   
   // SAFE
   random_bytes(32)
   random_int(0, PHP_INT_MAX)
   

   rustCopy code
   // Use rand crate with OsRng
   use rand::rngs::OsRng;
   let random: u64 = OsRng.gen();
   

   javaCopy code
   // VULNERABLE
   new Random().nextInt()
   
   // SAFE
   new SecureRandom().nextInt()
   

2. Token Generation Analyst:

   • "Check security token generation."

Phase 5: Secrets in Code (3 Parallel Agents)

1. Hardcoded Secrets Scanner:

   • "Deep scan for hardcoded secrets."

   Patterns:

   Copy code
   # AWS
   AKIA[0-9A-Z]{16}
   
   # GitHub
   ghp_[a-zA-Z0-9]{36}
   github_pat_[a-zA-Z0-9]{22}_[a-zA-Z0-9]{59}
   
   # Stripe
   sk_live_[a-zA-Z0-9]{24}
   rk_live_[a-zA-Z0-9]{24}
   
   # Private Keys
   -----BEGIN (RSA|EC|OPENSSH|PGP) PRIVATE KEY-----
   
   # Generic
   (password|secret|key|token|api_key)\s*[:=]\s*['\"][^'\"]+['\"]
   

2. Secret Exposure Analyst:

   • "Check where secrets might leak."

   Locations:

   • Log files
   • Error messages
   • API responses
   • Client-side code
   • Git history

3. Environment Variable Analyst:

   • "Check .env file security."

   Issues:

   • .env in repository
   • .env.example with real secrets
   • Missing .env in .gitignore

Output Requirements

Create deliverables/crypto_security_analysis.md:

markdownCopy code
# Cryptographic Security Analysis

## Summary
| Category | Issues | Critical | High | Medium |
|----------|--------|----------|------|--------|
| JWT | X | Y | Z | W |
| Hashing | X | Y | Z | W |
| Encryption | X | Y | Z | W |
| Random | X | Y | Z | W |
| Secrets | X | Y | Z | W |

## Language/Framework Detected
- Primary: [e.g., Node.js, Go, Python]
- Crypto Libraries: [e.g., crypto, bcrypt, jose]

## JWT Security Status

| Check | Status | Details |
|-------|--------|---------|
| Algorithm Validation | FAIL | Accepts 'none' algorithm |
| Secret Strength | FAIL | 8 character secret |
| Expiration | PASS | 1 hour expiry enforced |
| Issuer Validation | WARN | Not validated |

## Critical Findings

### [CRYPTO-001] JWT Algorithm Confusion
**Severity:** Critical
**Language:** Node.js
**Location:** `middleware/auth.js:23`

**Vulnerable Code:**
```javascript
const decoded = jwt.verify(token, publicKey);

Attack:

1. Take valid RS256 token
2. Change header to HS256
3. Sign with public key as secret
4. Server verifies with public key as HMAC secret

Remediation:

javascriptCopy code
const decoded = jwt.verify(token, publicKey, {
  algorithms: ['RS256']
});

[CRYPTO-002] MD5 Password Hashing

Severity: Critical Language: Python Location: models/user.py:45

Vulnerable Code:

pythonCopy code
hashed = hashlib.md5(password.encode()).hexdigest()

Remediation:

pythonCopy code
import bcrypt
hashed = bcrypt.hashpw(password.encode(), bcrypt.gensalt(rounds=12))

Password Hashing Status

Encryption Status

Random Number Generation

Hardcoded Secrets Found

Recommendations

Immediate Actions

1. Implement algorithm validation for JWT
2. Migrate password hashing to Argon2id or bcrypt (cost 12+)
3. Move all secrets to environment variables
4. Replace Math.random() with crypto.randomBytes()

Hashing Migration Guide

javascriptCopy code
// Before
const hash = md5(password);

// After
const hash = await bcrypt.hash(password, 12);

// Or with Argon2
const hash = await argon2.hash(password, {
  type: argon2.argon2id,
  memoryCost: 65536,
  timeCost: 3,
  parallelism: 4
});

Copy code

**Next Step:** JWT vulnerabilities can be verified with crafted tokens.