Skip to content

scottsen/vanikeys

BranchesTags

Repository files navigation

title project type status revenue_target beth_topics
VaniKeys - Zero-Knowledge Vanity SSH Keys
vanikeys
software
active
600000-3600000
vanikeys
cryptography
vanity-addresses
key-generation
did
blockchain
security
gpu-acceleration
gamification
gacha-mechanics
token-economy
saas
ssh-keys
zero-knowledge
hd-derivation

VaniKeys - Zero-Knowledge Vanity SSH Keys

Enterprise-grade vanity key generation. You keep the private key, we do the compute.

Turn your SSH keys from random strings into branded, identifiable credentials - without ever sharing your private keys.

🎯 The Problem We Solve

Traditional Vanity Key Services Are Broken

❌ You order vanity key → Service generates keys → Service sends private key
                                                   ↑
                                        THEY KNOW YOUR PRIVATE KEY

This is unacceptable for:

  • Production SSH keys
  • Enterprise security
  • Compliance requirements
  • DevOps infrastructure

Why existing services fail:

  • Must see your private key to find vanity patterns
  • Creates insider threat risk
  • Violates security best practices
  • Deal-breaker for enterprise buyers

✅ The VaniKeys Solution: Zero-Knowledge Protocol

✓ You generate seed → VaniKeys finds path → You derive key locally
                                             ↑
                                 YOUR PRIVATE KEY NEVER LEAVES YOUR MACHINE

How it works:

  1. You keep a secret seed (never shared)
  2. VaniKeys searches millions of derivation paths
  3. VaniKeys tells you which path produces vanity pattern
  4. You derive the key on your machine
  5. VaniKeys never sees your private key

Result: You get computational power without the trust risk.

This is not just a feature - it's what makes enterprise vanity keys possible.

🚀 Quick Start

Get Your First Vanity Key (5 Minutes)

# Install VaniKeys CLI
pip install vanikeys-client

# Initialize your seed (stays on your machine)
vanikeys init

# Order vanity SSH key
vanikeys order ssh --pattern "dev123"
# → VaniKeys searches millions of paths (~30 seconds)
# → Order: ord_abc123, Status: FOUND

# Verify and derive your key locally
vanikeys verify ord_abc123  # ✓ Cryptographic proof valid
vanikeys derive ord_abc123 --output ~/.ssh/dev_key

# Use your vanity key
ssh-keygen -lf ~/.ssh/dev_key.pub
# 256 SHA256:dev123xxxxxxxxxxxxxxxxxxxxxxxxx no comment (ED25519)

Your private key was generated on your machine. VaniKeys never saw it.

🌟 Why VaniKeys?

The Only Vanity Key Service with Zero-Knowledge Guarantees

Feature VaniKeys Traditional Services
Private key security ✅ Never leaves your machine ❌ Service knows your key
Cryptographic proofs ✅ Verifiable before use ❌ "Trust us"
Enterprise-ready ✅ Audit-friendly, compliant ❌ Security violation
Insider threat ✅ Impossible ❌ High risk
Computational leverage ✅ GPU acceleration ✅ Yes
Mathematical guarantee ✅ HD derivation protocol ❌ No

Technical deep dive: See docs/ZERO_KNOWLEDGE_PROTOCOL.md

💼 Use Cases

DevOps Teams

Problem: 500 developers with random SSH keys. Which key belongs to whom?

Solution: Branded vanity keys for your organization.

# DevOps manager orders bulk keys
vanikeys order bulk --pattern "acme-dev" --quantity 500

# Each team member gets identifiable key:
SHA256:acmedevxxxxxxxxxxxxxxxxxxxxxxxxx

Benefits:

  • Audit trail: See who accessed what at a glance
  • Security: Spot unauthorized keys immediately
  • Onboarding: Standardized key generation
  • Compliance: Traceable credential management

Platform Engineering

Problem: Multiple environments, keys getting mixed up.

Solution: Environment-specific vanity patterns.

vanikeys order ssh --pattern "prod"     # Production keys
vanikeys order ssh --pattern "staging"  # Staging keys
vanikeys order ssh --pattern "dev"      # Development keys

Result: Can't accidentally use wrong key for wrong environment.

Security Teams

Problem: Need to rotate 1000+ SSH keys across infrastructure.

Solution: Versioned vanity keys for rotation tracking.

vanikeys order bulk --pattern-template "infra-v2-{001..1000}"

# Clear visual distinction:
# Old: SHA256:infrav1001...
# New: SHA256:infrav2001...

Training & Labs

Problem: Students need practice keys, distinct from real credentials.

Solution: Lab-branded keys that can't be confused with production.

vanikeys order bulk --pattern "lab" --quantity 100

# Visually obvious these are lab keys:
SHA256:lab123xxxxxxxxxxxxxxxxxxxxxxxxx

📊 Business Model

Target Market: Enterprise DevOps

Market Size:

  • B2B/Enterprise: Tens of millions of developers globally
  • Every tech company has DevOps teams needing SSH keys
  • Recurring revenue: Key rotation, team turnover

Competitive Landscape:

  • Almost no competition in zero-knowledge vanity SSH keys
  • Traditional vanity services focus on crypto addresses
  • Enterprise SSH key management is greenfield

Pricing

Individual Developers:

  • Pay-as-you-go: $0.50 - $50 per key (based on pattern difficulty)
  • Free tier: 3 keys/month (trial)

Team Plans:

  • $100/month: 50 keys included, $1.50/key after
  • $500/month: 500 keys included, $1.00/key after

Enterprise:

  • Custom pricing for 1000+ keys
  • Volume discounts (up to 30% off)
  • Dedicated compute clusters
  • On-premise deployment option

Pattern Difficulty:

Pattern Time Cost
3 chars < 1s $0.50
4 chars ~2s $1.00
5 chars ~30s $2.50
6 chars ~30m $10.00
7 chars ~20h $50.00

Revenue Projections (Year 1)

Conservative:

  • 10 enterprise customers × $500/month = $5K/month
  • 100 team customers × $100/month = $10K/month
  • 500 individuals × $10/month = $5K/month
  • Total: $20K/month = $240K/year

Target:

  • 50 enterprise × $500/month = $25K/month
  • 500 teams × $100/month = $50K/month
  • 2000 individuals × $20/month = $40K/month
  • Total: $115K/month = $1.4M/year

Aggressive (Product-Market Fit):

  • 200 enterprise × $1000/month = $200K/month
  • 2000 teams × $100/month = $200K/month
  • 10000 individuals × $30/month = $300K/month
  • Total: $700K/month = $8.4M/year

🏗️ Architecture

Technology Stack

Client CLI:

  • Python 3.8+ (cross-platform)
  • Ed25519 key generation (fast, modern)
  • Secure seed storage (encrypted with password)
  • Proof verification (zero-knowledge protocol)

Server API:

  • FastAPI (Python web framework)
  • PostgreSQL (orders, proofs, audit logs)
  • Redis (job queue, real-time status)
  • GPU compute (vanity path search)

Infrastructure:

  • RunPod Serverless: GPU compute ($0.008/job, <200ms cold start)
  • Cost: $24/month for 100 jobs/day
  • Scales automatically with demand

System Design

┌─────────────────────────────────────────────────────────┐
│ Customer Environment (Trusted)                           │
│                                                          │
│  ┌──────────────────────────────────────────────────┐  │
│  │ vanikeys CLI                                     │  │
│  │ • Master seed (encrypted, local)                 │  │
│  │ • Key derivation                                 │  │
│  │ • Proof verification                             │  │
│  └──────────────────────────────────────────────────┘  │
│                                                          │
│       ↕ Public data only (root public key, orders)      │
│                                                          │
└─────────────────────────────────────────────────────────┘

┌─────────────────────────────────────────────────────────┐
│ VaniKeys Infrastructure (Untrusted)                      │
│                                                          │
│  ┌──────────────────────────────────────────────────┐  │
│  │ API Server (FastAPI)                             │  │
│  │ • Order management                               │  │
│  │ • Job dispatch                                   │  │
│  │ • Proof generation                               │  │
│  └────────────┬─────────────────────────────────────┘  │
│               │                                          │
│  ┌────────────▼─────────────────────────────────────┐  │
│  │ Search Workers (GPU)                             │  │
│  │ • Test millions of derivation paths              │  │
│  │ • Find vanity pattern matches                    │  │
│  │ • CANNOT access private keys                     │  │
│  └──────────────────────────────────────────────────┘  │
│                                                          │
└─────────────────────────────────────────────────────────┘

Key Property: Trust boundary mathematically enforced by cryptographic one-way functions.

📁 Project Structure

vanikeys/
├── pyproject.toml              # Python project configuration
├── README.md                   # This file
├── CHANGELOG.md                # Version history
├── .env.example                # Environment template
│
├── src/
│   └── vanikeys/
│       ├── crypto/             # Core cryptography (HD derivation, proofs)
│       ├── domain/             # Models (Pattern, Key, Order, etc.)
│       ├── services/           # Business logic (SearchService, OrderService)
│       ├── repositories/       # Data access (OrderRepo, ProofRepo)
│       ├── api/                # FastAPI routes
│       ├── cli/                # Customer CLI tool
│       └── config/             # Configuration
│
├── tests/                      # Test suite
│   ├── test_crypto.py          # Cryptography tests (critical!)
│   ├── test_derivation.py      # HD derivation tests
│   ├── test_proofs.py          # Proof generation/verification
│   └── test_integration.py     # End-to-end tests
│
├── docs/                       # Documentation
│   ├── ZERO_KNOWLEDGE_PROTOCOL.md         # Protocol design (MUST READ)
│   ├── HD_DERIVATION_IMPLEMENTATION.md    # Implementation guide
│   ├── CUSTOMER_QUICKSTART.md             # Customer guide
│   └── DEPLOYMENT_GUIDE.md                # Deployment instructions
│
└── deployment/                 # Deployment scripts
    ├── deploy-staging.sh
    ├── deploy-production.sh
    └── rollback.sh

📚 Documentation

Core Technical Documentation

🔐 Security & Protocol (Start Here):

👥 Customer Documentation:

🚀 Operations:

Why Zero-Knowledge Matters

From ZERO_KNOWLEDGE_PROTOCOL.md:

"The VaniKeys Zero-Knowledge Protocol solves the fundamental trust problem in vanity key generation. Traditional services must generate and test private keys to find vanity patterns - when they find a match, they know your private key. This is unacceptable for production systems.

Our protocol uses Hierarchical Deterministic (HD) key derivation: we search the derivation space, not the key space. We tell you which path to take, not what the key is. Your private key is derived on your machine from your secret seed + the path we found.

Result: Mathematically proven security. VaniKeys never sees your private key. Not policy, not promises - cryptographic guarantees."

🚀 Development

Prerequisites

  • Python 3.10+
  • PostgreSQL 14+
  • Redis 7+
  • GPU (optional, for local search testing)

Setup Development Environment

# Install uv (fast package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh

# Create virtual environment
uv venv
source .venv/bin/activate

# Install project with dev dependencies
uv pip install -e ".[dev]"

# Setup infrastructure
docker-compose up -d

# Run database migrations
python -m vanikeys.migrations.run

# Run tests (especially crypto tests!)
pytest tests/test_crypto.py -v
pytest tests/test_derivation.py -v
pytest tests/test_proofs.py -v

Development Workflow

# Run full test suite
pytest

# Run with coverage
pytest --cov=src tests/

# Lint & format
ruff check .
ruff format .

# Type check (important for crypto code!)
mypy src/vanikeys/crypto/

# Explore code structure
reveal src/vanikeys/crypto/

🎯 Implementation Roadmap

Phase 1: MVP (Current - 4 weeks)

Week 1-2: Core Cryptography

  • ZERO_KNOWLEDGE_PROTOCOL.md specification ✅
  • HD_DERIVATION_IMPLEMENTATION.md guide ✅
  • Ed25519 HD derivation implementation
  • SSH fingerprint pattern matching
  • Proof generation/verification
  • Comprehensive crypto test suite

Week 3: Client CLI

  • Seed generation & secure storage
  • Order placement (API client)
  • Proof verification
  • Key derivation
  • Export to OpenSSH format

Week 4: Server API

  • FastAPI endpoints (order, status, verify)
  • GPU search workers
  • Database schema (orders, proofs)
  • Job queue (Redis)

Phase 2: Beta Launch (2 weeks)

  • Stripe integration (payments)
  • Pattern difficulty estimator
  • Progress tracking (real-time updates)
  • Beta testing (10 customers)
  • Documentation polish

Phase 3: Production (2 weeks)

  • Production deployment (tia-apps)
  • Monitoring & alerting
  • Customer support system
  • Public launch (Hacker News, DevOps communities)

Success Metrics (Month 1)

  • 50 beta signups
  • 10 paying customers
  • $500 revenue
  • 100+ keys generated
  • Zero security incidents

🏆 Competitive Advantages

vs. Traditional Vanity Generators

✅ Zero-knowledge protocol (we're the only one) ✅ Enterprise-ready (security + compliance) ✅ SSH/DevOps focus (bigger market than crypto) ✅ Cryptographic proofs (verifiable, auditable) ✅ B2B business model (recurring revenue)

vs. DIY Solutions

✅ GPU acceleration (100x faster than CPU) ✅ Zero trust required (verify proofs yourself) ✅ No technical knowledge needed (CLI is simple) ✅ Bulk generation (provision entire teams) ✅ Professional support (not just a script)

🤝 Contributing

This is a bootstrap opportunity (revenue-generating business), but best practices:

  1. Security is critical - crypto code must be perfect
  2. Write tests - especially for cryptography
  3. Document thoroughly - security relies on understanding
  4. Follow TIA Python Guide - clean architecture
  5. Use reveal - explore before modifying

📜 License

Proprietary - Revenue-generating business opportunity

🎬 Why This Will Succeed

Market Opportunity

✅ Large market: Every developer needs SSH keys ✅ Underserved: No zero-knowledge vanity key services exist ✅ B2B revenue: Enterprise buyers, recurring revenue ✅ Low competition: Existing services focus on crypto addresses ✅ Clear value prop: Security + branding + compliance

Technical Moat

✅ Zero-knowledge protocol: Hard to replicate correctly ✅ Cryptographic expertise: Security is complex ✅ Infrastructure: GPU compute optimization ✅ Documentation: Comprehensive technical docs

Bootstrap-Friendly

✅ Low capital: $0 upfront, $70/month infrastructure ✅ Fast to revenue: 6-8 weeks to first dollar ✅ High margins: 99%+ profit margin ✅ Scalable: Serverless GPU grows with demand

🚀 Get Started

For Customers:

pip install vanikeys-client
vanikeys init
vanikeys order ssh --pattern "myteam"

For Developers:

git clone https://github.com/scottsen/vanikeys.git
cd vanikeys
uv pip install -e ".[dev]"
pytest

For Enterprise: Contact: sales@vanikeys.dev

📞 Contact & Support

Version: 0.2.0 (Zero-Knowledge Protocol) Last Updated: 2025-12-03 Status: Phase 1 - MVP Development

Core Innovation: Zero-knowledge vanity key generation with cryptographic security guarantees. The only service where you never share your private keys.

About

No description, website, or topics provided.

Resources

Readme
Activity

Stars

0 stars

Watchers

0 watching

Forks

0 forks
Report repository

Releases

No releases published

Packages

No packages published

Contributors 2

  •  
  •  

Languages