home / skills / jeremylongshore / claude-code-plugins-plus-skills / vastai-security-basics

This skill helps you implement Vast.ai security best practices for secrets, access control, and auditing configuration across environments.

npx playbooks add skill jeremylongshore/claude-code-plugins-plus-skills --skill vastai-security-basics

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
3.4 KB
---
name: vastai-security-basics
description: |
  Apply Vast.ai security best practices for secrets and access control.
  Use when securing API keys, implementing least privilege access,
  or auditing Vast.ai security configuration.
  Trigger with phrases like "vastai security", "vastai secrets",
  "secure vastai", "vastai API key security".
allowed-tools: Read, Write, Grep
version: 1.0.0
license: MIT
author: Jeremy Longshore <[email protected]>
---

# Vast.ai Security Basics

## Overview
Security best practices for Vast.ai API keys, tokens, and access control.

## Prerequisites
- Vast.ai SDK installed
- Understanding of environment variables
- Access to Vast.ai dashboard

## Instructions

### Step 1: Configure Environment Variables
```bash
# .env (NEVER commit to git)
VASTAI_API_KEY=sk_live_***
VASTAI_SECRET=***

# .gitignore
.env
.env.local
.env.*.local
```

### Step 2: Implement Secret Rotation
```bash
# 1. Generate new key in Vast.ai dashboard
# 2. Update environment variable
export VASTAI_API_KEY="new_key_here"

# 3. Verify new key works
curl -H "Authorization: Bearer ${VASTAI_API_KEY}" \
  https://api.vastai.com/health

# 4. Revoke old key in dashboard
```

### Step 3: Apply Least Privilege
| Environment | Recommended Scopes |
|-------------|-------------------|
| Development | `read:*` |
| Staging | `read:*, write:limited` |
| Production | `Only required scopes` |

## Output
- Secure API key storage
- Environment-specific access controls
- Audit logging enabled

## Error Handling
| Security Issue | Detection | Mitigation |
|----------------|-----------|------------|
| Exposed API key | Git scanning | Rotate immediately |
| Excessive scopes | Audit logs | Reduce permissions |
| Missing rotation | Key age check | Schedule rotation |

## Examples

### Service Account Pattern
```typescript
const clients = {
  reader: new Vast.aiClient({
    apiKey: process.env.VASTAI_READ_KEY,
  }),
  writer: new Vast.aiClient({
    apiKey: process.env.VASTAI_WRITE_KEY,
  }),
};
```

### Webhook Signature Verification
```typescript
import crypto from 'crypto';

function verifyWebhookSignature(
  payload: string, signature: string, secret: string
): boolean {
  const expected = crypto.createHmac('sha256', secret).update(payload).digest('hex');
  return crypto.timingSafeEqual(Buffer.from(signature), Buffer.from(expected));
}
```

### Security Checklist
- [ ] API keys in environment variables
- [ ] `.env` files in `.gitignore`
- [ ] Different keys for dev/staging/prod
- [ ] Minimal scopes per environment
- [ ] Webhook signatures validated
- [ ] Audit logging enabled

### Audit Logging
```typescript
interface AuditEntry {
  timestamp: Date;
  action: string;
  userId: string;
  resource: string;
  result: 'success' | 'failure';
  metadata?: Record<string, any>;
}

async function auditLog(entry: Omit<AuditEntry, 'timestamp'>): Promise<void> {
  const log: AuditEntry = { ...entry, timestamp: new Date() };

  // Log to Vast.ai analytics
  await vastaiClient.track('audit', log);

  // Also log locally for compliance
  console.log('[AUDIT]', JSON.stringify(log));
}

// Usage
await auditLog({
  action: 'vastai.api.call',
  userId: currentUser.id,
  resource: '/v1/resource',
  result: 'success',
});
```

## Resources
- [Vast.ai Security Guide](https://docs.vastai.com/security)
- [Vast.ai API Scopes](https://docs.vastai.com/scopes)

## Next Steps
For production deployment, see `vastai-prod-checklist`.

Overview

This skill applies Vast.ai security best practices for API keys, tokens, and access control. It guides secure storage, rotation, and least-privilege configuration across development, staging, and production. Use it to harden integrations, webhook handling, and audit logging for Vast.ai usage.

How this skill works

It inspects your Vast.ai credential handling patterns and recommends concrete configuration changes: environment variable management, git ignore rules, and scoped API keys per environment. It provides step-by-step secret rotation, service-account patterns, webhook signature verification, and an audit logging pattern to record security-relevant events. It also maps common issues to detection and mitigation actions for quick remediation.

When to use it

  • Securing Vast.ai API keys before committing code
  • Implementing least-privilege access across dev/stage/prod
  • Auditing Vast.ai integration for exposed secrets or excessive scopes
  • Setting up webhook verification for Vast.ai callbacks
  • Establishing audit logging and rotation schedules

Best practices

  • Never commit .env or secret files; add .env and *.local to .gitignore
  • Store keys in environment variables or a secrets manager, not in code
  • Use separate API keys for development, staging, and production with minimal scopes
  • Rotate keys regularly and revoke old keys immediately after verification
  • Validate webhook signatures using HMAC and timing-safe comparison
  • Record audit entries for key actions and log them both remotely and locally

Example use cases

  • Set VASTAI_API_KEY and VASTAI_SECRET in CI/CD or a secrets manager, not in repository files
  • Rotate a compromised key: create new key, update env, test with a health endpoint, then revoke old key
  • Create reader and writer service accounts with distinct keys and limited scopes
  • Validate incoming webhooks using HMAC-SHA256 and timing-safe comparison to prevent replay or tampering
  • Implement an auditLog function to capture timestamp, action, userId, resource, and result for compliance

FAQ

How often should I rotate Vast.ai API keys?

Rotate keys on a regular schedule and immediately after suspected exposure; common cadence is every 90 days, but adjust to your risk profile.

What scopes should production keys have?

Grant production keys only the exact scopes required for the service to function; avoid broad read:* or write:* unless strictly necessary.