@rune-kit/rune 2.3.3 → 2.4.0

package/skills/sentinel/SKILL.md

@@ -3,7 +3,7 @@ name: sentinel
 description: Automated security gatekeeper. Blocks unsafe code before commit — secret scanning, OWASP top 10, dependency audit, permission checks. A GATE, not a suggestion.
 metadata:
   author: runedev
-  version: "0.7.0"
+  version: "0.8.0"
   layer: L2
   model: sonnet
   group: quality
@@ -96,6 +96,7 @@ Use `Grep` on all changed files for core patterns: `sk-`, `AKIA`, `ghp_`, `ghs_`
 Any match = **BLOCK**. Do not proceed to later steps if BLOCK findings exist — report immediately.
 
 ### Step 2 — Dependency Audit
+<MUST-READ path="references/supply-chain.md" trigger="When dependency changes detected (package.json, package-lock.json, requirements.txt, Cargo.toml modified) — load typosquatting prevention, lock file rules, SRI, npm hardening"/>
 
 Use `Bash` to run the appropriate audit command for the detected package manager:
 - npm/pnpm/yarn: `npm audit --json` (parse JSON, extract critical + high severity)
@@ -122,6 +123,7 @@ If 3+ signals fire for a single dependency → **BLOCK** with recommendation: "C
 
 ### Step 3 — OWASP Check
 <MUST-READ path="references/owasp-patterns.md" trigger="Before scanning for OWASP issues — load code examples and detection signals for SQL injection, XSS, CSRF, input validation"/>
+<MUST-READ path="references/auth-crypto-reference.md" trigger="When authentication, password hashing, encryption, or token management patterns detected — load Argon2id params, JWT best practices, OAuth2 PKCE, AES-256-GCM, fail-closed principle"/>
 
 Scan changed files for SQL injection (string concat/interpolation in SQL) → **BLOCK**, XSS (`innerHTML`, `dangerouslySetInnerHTML` without sanitization) → **BLOCK**, CSRF (forms without token, cookies without SameSite) → **WARN**, and missing input validation (raw `req.body` → DB) → **WARN**. Load reference for code examples and precise detection signals.
 
@@ -140,6 +142,7 @@ When invoked on `SKILL.md`, `extensions/*/PACK.md`, `.rune/*.md`, or agent files
 
 ### Step 4.5 — Framework-Specific Security Patterns
 <MUST-READ path="references/framework-patterns.md" trigger="When framework files are detected in the changed set — load patterns for the specific framework(s) found"/>
+<MUST-READ path="references/desktop-security.md" trigger="When Electron or Tauri project detected (package.json contains electron, @tauri-apps/cli, or tauri.conf.json exists) — load BrowserWindow config, IPC validation, scope restrictions, code signing"/>
 
 Apply only when the framework is detected in changed files. Covers Django (DEBUG=True, missing permissions, CSRF removal), React/Next.js (localStorage JWT, dangerouslySetInnerHTML), Node.js/Express/Fastify (wildcard CORS, missing helmet), Python (pickle.loads, yaml.load unsafe). Load reference for the complete check table per framework.
 

package/skills/sentinel/references/auth-crypto-reference.md

@@ -0,0 +1,192 @@
+# Auth & Cryptography Reference
+
+> Loaded by `sentinel` when authentication, password hashing, encryption, or token management patterns detected.
+
+---
+
+## Password Hashing
+
+### Recommended: Argon2id
+
+```javascript
+import { hash, verify } from '@node-rs/argon2';
+
+// Hash — use these parameters minimum
+const hashed = await hash(password, {
+  memoryCost: 65536,    // 64 MB
+  timeCost: 3,          // 3 iterations
+  parallelism: 4,       // 4 threads
+  outputLen: 32,        // 32 bytes
+});
+
+// Verify
+const valid = await verify(hashed, password);
+```
+
+### Acceptable: bcrypt
+
+```javascript
+import bcrypt from 'bcrypt';
+
+const ROUNDS = 12; // minimum 12, never below 10
+const hashed = await bcrypt.hash(password, ROUNDS);
+const valid = await bcrypt.compare(password, hashed);
+```
+
+### Severity Table
+
+| Algorithm | Verdict | Action |
+|-----------|---------|--------|
+| Argon2id | PASS | Preferred |
+| bcrypt (rounds ≥ 12) | PASS | Acceptable |
+| bcrypt (rounds < 10) | WARN | Increase rounds |
+| scrypt | WARN | Prefer Argon2id |
+| SHA-256/SHA-512 + salt | BLOCK | Not a password hash |
+| MD5 / SHA-1 | BLOCK | Broken, must replace |
+| Plaintext | BLOCK | Critical vulnerability |
+
+---
+
+## JWT Best Practices
+
+### Token Lifecycle
+
+```javascript
+// Access token: short-lived (15 min)
+const accessToken = jwt.sign(
+  { sub: user.id, role: user.role },
+  process.env.JWT_SECRET,
+  { expiresIn: '15m', algorithm: 'HS256' }
+);
+
+// Refresh token: longer (7 days), stored in HttpOnly cookie
+const refreshToken = jwt.sign(
+  { sub: user.id, type: 'refresh' },
+  process.env.JWT_REFRESH_SECRET,
+  { expiresIn: '7d' }
+);
+
+res.cookie('refresh_token', refreshToken, {
+  httpOnly: true,     // No JavaScript access
+  secure: true,       // HTTPS only
+  sameSite: 'strict', // No cross-site
+  maxAge: 7 * 24 * 60 * 60 * 1000,
+  path: '/api/auth/refresh', // Only sent to refresh endpoint
+});
+```
+
+### JWT BLOCK Patterns
+
+| Pattern | Severity | Fix |
+|---------|----------|-----|
+| `algorithm: 'none'` | BLOCK | Always specify algorithm |
+| No `expiresIn` | BLOCK | Tokens MUST expire |
+| Secret < 32 chars | WARN | Use 256-bit minimum |
+| JWT in localStorage | WARN | Use HttpOnly cookie for refresh |
+| No audience/issuer validation | WARN | Add `aud` and `iss` claims |
+
+---
+
+## OAuth2 with PKCE
+
+```javascript
+// 1. Generate PKCE challenge
+const codeVerifier = crypto.randomBytes(32).toString('base64url');
+const codeChallenge = crypto
+  .createHash('sha256')
+  .update(codeVerifier)
+  .digest('base64url');
+
+// 2. Authorization URL
+const authUrl = new URL('https://provider.com/authorize');
+authUrl.searchParams.set('response_type', 'code');
+authUrl.searchParams.set('client_id', CLIENT_ID);
+authUrl.searchParams.set('redirect_uri', REDIRECT_URI);
+authUrl.searchParams.set('code_challenge', codeChallenge);
+authUrl.searchParams.set('code_challenge_method', 'S256');
+authUrl.searchParams.set('state', crypto.randomBytes(16).toString('hex'));
+
+// 3. Exchange code (callback) — include code_verifier
+const tokenResponse = await fetch('https://provider.com/token', {
+  method: 'POST',
+  headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+  body: new URLSearchParams({
+    grant_type: 'authorization_code',
+    code: authorizationCode,
+    redirect_uri: REDIRECT_URI,
+    client_id: CLIENT_ID,
+    code_verifier: codeVerifier, // Proves we initiated the flow
+  }),
+});
+```
+
+---
+
+## Encryption (Data at Rest)
+
+### AES-256-GCM (Recommended)
+
+```javascript
+import { createCipheriv, createDecipheriv, randomBytes } from 'crypto';
+
+const ALGORITHM = 'aes-256-gcm';
+const KEY = Buffer.from(process.env.ENCRYPTION_KEY, 'hex'); // 32 bytes
+
+function encrypt(plaintext) {
+  const iv = randomBytes(16);
+  const cipher = createCipheriv(ALGORITHM, KEY, iv);
+  const encrypted = Buffer.concat([cipher.update(plaintext, 'utf8'), cipher.final()]);
+  const tag = cipher.getAuthTag();
+  // Store: iv + tag + ciphertext (all needed for decryption)
+  return Buffer.concat([iv, tag, encrypted]).toString('base64');
+}
+
+function decrypt(encoded) {
+  const buffer = Buffer.from(encoded, 'base64');
+  const iv = buffer.subarray(0, 16);
+  const tag = buffer.subarray(16, 32);
+  const ciphertext = buffer.subarray(32);
+  const decipher = createDecipheriv(ALGORITHM, KEY, iv);
+  decipher.setAuthTag(tag);
+  return decipher.update(ciphertext) + decipher.final('utf8');
+}
+```
+
+### Crypto Rules
+
+| Use Case | Algorithm | BLOCK If |
+|----------|-----------|----------|
+| Password storage | Argon2id / bcrypt | MD5, SHA-*, plaintext |
+| Data encryption | AES-256-GCM | AES-ECB, DES, RC4 |
+| Integrity check | SHA-256 | MD5, SHA-1 |
+| Signatures | HMAC-SHA256 | Custom MAC |
+| Random tokens | `crypto.randomBytes()` | `Math.random()` |
+| Key derivation | scrypt / HKDF | Simple hash |
+
+---
+
+## Fail-Closed Principle
+
+Errors MUST deny access, never grant it:
+
+```javascript
+// BAD: fail-open — error grants access
+function authorize(user) {
+  try {
+    return checkPermission(user);
+  } catch {
+    return true; // BLOCK: error = access granted
+  }
+}
+
+// GOOD: fail-closed — error denies access
+function authorize(user) {
+  try {
+    return checkPermission(user);
+  } catch {
+    return false; // Error = denied
+  }
+}
+```
+
+**BLOCK pattern**: Any catch/except block that returns `true`, `next()`, or allows continuation on auth/permission check failure.

package/skills/sentinel/references/desktop-security.md

@@ -0,0 +1,201 @@
+# Desktop App Security Reference
+
+> Loaded by `sentinel` when Electron or Tauri project detected (package.json contains `electron`, `@tauri-apps/cli`, or `tauri.conf.json` exists).
+
+---
+
+## Electron Security
+
+### Secure BrowserWindow Config
+
+Every BrowserWindow MUST use:
+
+```javascript
+const win = new BrowserWindow({
+  webPreferences: {
+    contextIsolation: true,      // REQUIRED — separates preload from page
+    nodeIntegration: false,       // REQUIRED — no Node in renderer
+    sandbox: true,                // REQUIRED — OS-level sandbox
+    webSecurity: true,            // REQUIRED — enforce same-origin
+    allowRunningInsecureContent: false,
+    experimentalFeatures: false,
+  }
+});
+```
+
+**BLOCK if any of these are wrong:**
+- `contextIsolation: false` — renderer can access Node APIs
+- `nodeIntegration: true` — XSS = full system compromise
+- `sandbox: false` — no OS isolation
+- `webSecurity: false` — disables same-origin policy
+
+### Preload Script (Minimal Surface)
+
+Expose only specific functions, never blanket APIs:
+
+```javascript
+// preload.js — GOOD: minimal, typed API
+const { contextBridge, ipcRenderer } = require('electron');
+
+contextBridge.exposeInMainWorld('api', {
+  readFile: (path) => ipcRenderer.invoke('fs:read', path),
+  saveFile: (path, data) => ipcRenderer.invoke('fs:save', path, data),
+  // NEVER expose: ipcRenderer.send, ipcRenderer.on, require, process
+});
+```
+
+### IPC Validation
+
+Validate BOTH sender identity and message content:
+
+```javascript
+// main.js — validate IPC
+ipcMain.handle('fs:read', async (event, filePath) => {
+  // 1. Verify sender
+  if (event.senderFrame.url !== 'app://./index.html') {
+    throw new Error('Unauthorized IPC sender');
+  }
+
+  // 2. Validate input
+  const resolved = path.resolve(filePath);
+  if (!resolved.startsWith(ALLOWED_DIR)) {
+    throw new Error('Path traversal blocked');
+  }
+
+  return fs.readFileSync(resolved, 'utf-8');
+});
+```
+
+### Deep Link Validation
+
+```javascript
+// Validate protocol handler input
+app.setAsDefaultProtocolClient('myapp');
+
+app.on('open-url', (event, url) => {
+  event.preventDefault();
+
+  const parsed = new URL(url);
+  const ALLOWED_HOSTS = ['app.example.com'];
+  const ALLOWED_PROTOCOLS = ['myapp:'];
+
+  if (!ALLOWED_PROTOCOLS.includes(parsed.protocol)) return;
+  if (parsed.host && !ALLOWED_HOSTS.includes(parsed.host)) return;
+  if (url.length > 2048) return; // Length limit
+
+  handleDeepLink(parsed);
+});
+```
+
+### Electron Vulnerability Checklist
+
+| Check | BLOCK if |
+|-------|----------|
+| `nodeIntegration` | `true` in any window |
+| `contextIsolation` | `false` in any window |
+| `sandbox` | `false` in any window |
+| `webSecurity` | `false` |
+| Preload exposes `ipcRenderer.send` | Direct IPC channel exposed |
+| IPC handler missing sender check | No `event.senderFrame` validation |
+| `shell.openExternal` unvalidated | User-controlled URLs passed directly |
+| Auto-updater over HTTP | Not using HTTPS or missing signature check |
+| `webview` tag without sandbox | Embedded content without isolation |
+| Deep links unvalidated | No protocol/host allowlist |
+
+---
+
+## Tauri Security
+
+### Command Security
+
+```rust
+// GOOD: Strict typing + validation
+#[tauri::command]
+fn read_file(path: String) -> Result<String, String> {
+    let canonical = std::fs::canonicalize(&path)
+        .map_err(|e| e.to_string())?;
+
+    // Validate path is within allowed directory
+    if !canonical.starts_with("/allowed/dir") {
+        return Err("Access denied".into());
+    }
+
+    std::fs::read_to_string(canonical)
+        .map_err(|e| e.to_string())
+}
+```
+
+### Scope Configuration
+
+```json
+// tauri.conf.json — restrictive scopes
+{
+  "tauri": {
+    "allowlist": {
+      "fs": {
+        "scope": ["$APPDATA/*", "$RESOURCE/*"],
+        "readFile": true,
+        "writeFile": true
+      },
+      "http": {
+        "scope": ["https://api.example.com/*"]
+      },
+      "shell": {
+        "open": true,
+        "scope": []
+      }
+    }
+  }
+}
+```
+
+**BLOCK if:**
+- `fs.scope: ["**"]` — unrestricted filesystem access
+- `http.scope: ["https://**"]` — any HTTPS target
+- `shell.scope` contains executable paths without validation
+
+### Tauri Vulnerability Checklist
+
+| Check | BLOCK if |
+|-------|----------|
+| `fs.scope` | Contains `**` or `/` (unrestricted) |
+| `http.scope` | Broad wildcard allowing arbitrary hosts |
+| `shell` commands | Unrestricted `execute` scope |
+| CSP missing | No Content-Security-Policy in `tauri.conf.json` |
+| `invoke()` handler | Missing input validation or type checking |
+
+---
+
+## Common Desktop Patterns
+
+### Code Signing
+
+Always sign releases — unsigned apps trigger OS warnings and can be tampered with:
+
+- **Windows**: EV code signing certificate (hardware token)
+- **macOS**: Developer ID certificate + notarization (`xcrun notarytool`)
+- **Linux**: GPG signing for packages
+
+### Secure Auto-Update
+
+```
+1. Check for update over HTTPS
+2. Verify digital signature of update package
+3. Verify SHA-256 checksum
+4. Prompt user before installing (never silent)
+5. Graceful fallback if update fails
+```
+
+### Credential Storage
+
+```javascript
+// Electron — use safeStorage (OS keychain)
+const { safeStorage } = require('electron');
+
+if (safeStorage.isEncryptionAvailable()) {
+  const encrypted = safeStorage.encryptString(token);
+  // Store encrypted buffer, never plaintext
+}
+```
+
+**BLOCK**: Storing credentials in `localStorage`, plain files, or `electron-store` without encryption.

package/skills/sentinel/references/supply-chain.md

@@ -0,0 +1,160 @@
+# Supply Chain Security Reference
+
+> Loaded by `sentinel` when dependency changes detected (package.json, package-lock.json, requirements.txt, Cargo.toml modified).
+
+---
+
+## Dependency Audit
+
+### Required Checks
+
+On every dependency change, verify:
+
+```bash
+# Node.js
+npm audit --audit-level=high
+npm audit signatures  # Verify registry signatures
+
+# Python
+pip-audit
+safety check
+
+# Rust
+cargo audit
+```
+
+**BLOCK**: Any `high` or `critical` severity vulnerability in direct dependencies.
+**WARN**: `high`/`critical` in transitive dependencies.
+
+---
+
+## Lock File Rules
+
+| Rule | Severity |
+|------|----------|
+| Lock file not committed | BLOCK |
+| Lock file deleted | BLOCK |
+| Lock file modified without package.json change | WARN (investigate) |
+| Multiple lock files (package-lock + yarn.lock) | WARN |
+
+Lock files pin exact versions. Without them, builds are non-reproducible and vulnerable to supply chain attacks.
+
+---
+
+## Typosquatting Prevention
+
+Before adding ANY new dependency, check:
+
+| Signal | Example | Risk |
+|--------|---------|------|
+| Name differs by 1 char | `lodsh` vs `lodash` | Typosquat |
+| Extra hyphen/underscore | `react-domm` | Typosquat |
+| Scoped look-alike | `@react/core` vs `react` | Impersonation |
+| Very new package | Published < 7 days ago | Suspicious |
+| Low download count | < 100 weekly downloads | Unvetted |
+| No repository URL | Missing `repository` field | Cannot verify source |
+
+### Scan Pattern
+
+```javascript
+// sentinel should flag new dependencies added to package.json
+// Check against known package names for close matches
+const KNOWN_PACKAGES = ['lodash', 'express', 'react', 'axios', ...];
+
+function checkTyposquat(name) {
+  for (const known of KNOWN_PACKAGES) {
+    if (levenshteinDistance(name, known) === 1) {
+      return { risk: 'HIGH', similar: known };
+    }
+  }
+}
+```
+
+---
+
+## Version Pinning Strategy
+
+| Dependency Type | Strategy | Why |
+|----------------|----------|-----|
+| Direct (production) | `^` semver (default) | Balance updates + stability |
+| Security-critical | Exact pin (`1.2.3`) | Prevent unexpected changes |
+| Dev tools | `^` semver | Less risk, want updates |
+| CDN resources | SRI hash required | Tamper detection |
+
+### Subresource Integrity (SRI)
+
+For any CDN-loaded script or stylesheet:
+
+```html
+<!-- GOOD: SRI hash verifies integrity -->
+<script
+  src="https://cdn.example.com/lib.js"
+  integrity="sha384-abc123..."
+  crossorigin="anonymous"
+></script>
+
+<!-- BLOCK: CDN resource without SRI -->
+<script src="https://cdn.example.com/lib.js"></script>
+```
+
+---
+
+## npm Security Hardening
+
+| Practice | Priority |
+|----------|----------|
+| Enable 2FA on npm account | BLOCK (maintainers) |
+| Use scoped packages (`@org/pkg`) | Recommended |
+| `npm audit` in CI pipeline | Required |
+| `npm audit signatures` | Recommended |
+| Review `postinstall` scripts | Required for new deps |
+| Use `--ignore-scripts` for untrusted packages | Recommended |
+
+### Dangerous Install Scripts
+
+**WARN** when a newly added package has `postinstall`, `preinstall`, or `install` scripts:
+
+```json
+// package.json of dependency — review these carefully
+{
+  "scripts": {
+    "postinstall": "node setup.js"  // What does this run?
+  }
+}
+```
+
+---
+
+## Automated Dependency Updates
+
+Configure one of:
+
+```yaml
+# .github/dependabot.yml
+version: 2
+updates:
+  - package-ecosystem: npm
+    directory: /
+    schedule:
+      interval: weekly
+    open-pull-requests-limit: 10
+    reviewers:
+      - security-team
+```
+
+**WARN** if no automated dependency update tool is configured (Dependabot, Renovate, or Snyk).
+
+---
+
+## Security Checklist for New Dependencies
+
+Before approving a new dependency:
+
+- [ ] Package name is correct (not a typosquat)
+- [ ] Has significant download count (>1K/week for niche, >10K for common)
+- [ ] Repository URL exists and matches claimed source
+- [ ] No known vulnerabilities (`npm audit`)
+- [ ] License is compatible
+- [ ] Install scripts reviewed (if any)
+- [ ] Maintainer has 2FA enabled (check npm profile)
+- [ ] Not abandoned (last publish < 12 months)