Sirius Scan v1.0.0

Sirius is an open-source comprehensive vulnerability scanner that leverages community-driven security intelligence and automated penetration testing capabilities. v1.0.0 is the first production release, bringing the complete scanning platform, hardened CI/CD workflows, and release-grade deployment readiness. Get started in minutes with our Docker-based setup.

Navigate by Role

• End Users: Quick Start, Installation, Interface Tour
• Contributors: CONTRIBUTING.md, Issue Tracker, Discussions
• Maintainers: Maintainer Ops Review, CI/CD Guide, Container Testing

🚀 Quick Start Guide

Prerequisites

• Docker Engine 20.10.0+ with Docker Compose V2
• System Requirements: 4GB RAM minimum, 10GB free disk space
• Network Access: Internet connectivity for vulnerability database updates
• Supported Platforms: Linux, macOS, Windows (with WSL2)

⚡ Quick Start (Current Runtime Requirements)

⚡ Startup Command Cheat Sheet

# 1) Generate/merge required runtime secrets (.env)
docker compose -f docker-compose.installer.yaml run --rm sirius-installer

# 2a) Start standard stack
docker compose up -d

# 2b) Start development overlay
docker compose -f docker-compose.yaml -f docker-compose.dev.yaml up -d

# 2c) Optional hardened production overlay
docker compose -f docker-compose.yaml -f docker-compose.prod.yaml up -d

# Clone repository
git clone https://github.com/SiriusScan/Sirius.git
cd Sirius

# Generate and validate startup secrets/config (installer-first)
docker compose -f docker-compose.installer.yaml run --rm sirius-installer

# Start Sirius with release images
docker compose up -d

# Access the web interface
open http://localhost:3000

Important:

• SIRIUS_API_KEY is required for sirius-ui, sirius-api, and sirius-engine.
• POSTGRES_PASSWORD, NEXTAUTH_SECRET, and INITIAL_ADMIN_PASSWORD are required.
• This repository does not include docker-compose.user.yaml; use docker-compose.yaml, docker-compose.dev.yaml, and docker-compose.prod.yaml.

🧭 Using the New Startup System

Sirius now uses an installer-first startup flow. This keeps secrets synchronized across services and removes insecure defaults.

1) First-time local setup (interactive)

docker compose -f docker-compose.installer.yaml run --rm sirius-installer
docker compose up -d

What happens:

• Reads .env.production.example
• Merges existing .env values if present
• Generates missing required values:
  • SIRIUS_API_KEY
  • POSTGRES_PASSWORD
  • NEXTAUTH_SECRET
  • INITIAL_ADMIN_PASSWORD

2) Non-interactive setup (CI/Terraform/user-data)

docker compose -f docker-compose.installer.yaml run --rm sirius-installer --non-interactive --no-print-secrets
docker compose up -d

3) Force secret rotation/regeneration

docker compose -f docker-compose.installer.yaml run --rm sirius-installer --force

4) Development overlay startup

docker compose -f docker-compose.installer.yaml run --rm sirius-installer
docker compose -f docker-compose.yaml -f docker-compose.dev.yaml up -d

5) Verify configuration renders

SIRIUS_API_KEY=test-key \
POSTGRES_PASSWORD=test-pass \
NEXTAUTH_SECRET=test-secret \
INITIAL_ADMIN_PASSWORD=test-admin-pass \
docker compose config --quiet

🆕 What's New in v1.0.0

System Monitoring & Observability

• Real-time Health Monitoring: Live service health checks for all components
• Centralized Logging: Unified log collection and management system
• Performance Metrics: Container resource utilization tracking
• System Dashboard: Comprehensive monitoring interface at /system-monitor

Enhanced Reliability

• Improved Container Builds: Production-ready Docker configurations
• Better Error Handling: Comprehensive error management and recovery
• SSH Troubleshooting: Enhanced debugging capabilities for deployments
• Automated Testing: Robust container testing and validation

🔧 Installation Options

Option 1: Standard Setup (Recommended for Most Users)

The default configuration provides a complete scanning environment:

git clone https://github.com/SiriusScan/Sirius.git
cd Sirius
docker compose -f docker-compose.installer.yaml run --rm sirius-installer
docker compose up -d

Quick-start resilience: if the shared GHCR base-builder image is unavailable, infra services (sirius-valkey, sirius-postgres, sirius-rabbitmq) now build system-monitor locally during image build.

Option 2: Local Development Overlay

Use live-reload/development mounts for active code work:

git clone https://github.com/SiriusScan/Sirius.git
cd Sirius
docker compose -f docker-compose.installer.yaml run --rm sirius-installer
docker compose -f docker-compose.yaml -f docker-compose.dev.yaml up -d

Option 3: Production Overlay

Optional hardened production settings and validation overlay:

git clone https://github.com/SiriusScan/Sirius.git
cd Sirius
docker compose -f docker-compose.installer.yaml run --rm sirius-installer
docker compose -f docker-compose.yaml -f docker-compose.prod.yaml up -d

Host Discovery Prerequisites (All Compose Modes)

• sirius-engine runs with NET_RAW capability in base/dev/prod compose configurations for ICMP-based fingerprint discovery.
• Keep SIRIUS_API_URL and API_BASE_URL pointing to http://sirius-api:9001 for container-to-container API persistence.
• Use NEXT_PUBLIC_SIRIUS_API_URL=http://localhost:9001 so browser calls hit the host-exposed API.

✅ Verify Installation

# Check all services are running
docker ps

# Expected services:
# - sirius-ui (port 3000)
# - sirius-api (port 9001)
# - sirius-engine (ports 5174, 50051)
# - sirius-postgres (port 5432)
# - sirius-rabbitmq (ports 5672, 15672)
# - sirius-valkey (port 6379)

# Access web interface
curl http://localhost:3000

# Check API health
curl http://localhost:9001/health

Clean Rollout Verification (Fresh Clone)

Use this sequence to validate a production rollout from a fresh checkout.

# 1) Start from a clean runtime state
docker compose down -v --remove-orphans

# 2) Generate runtime secrets/config
docker compose -f docker-compose.installer.yaml run --rm sirius-installer --non-interactive --no-print-secrets

# 3) Build from local source deterministically (no registry pulls)
env -u SIRIUS_API_KEY -u POSTGRES_PASSWORD -u NEXTAUTH_SECRET -u INITIAL_ADMIN_PASSWORD \
SIRIUS_IMAGE_PULL_POLICY=never docker compose up -d --build

# 4) Confirm all services are healthy
docker compose ps

# 5) Validate API auth behavior
curl -i http://localhost:9001/host/            # expect 401 (no key)
RUNTIME_KEY=$(docker inspect sirius-api --format '{{range .Config.Env}}{{println .}}{{end}}' | rg '^SIRIUS_API_KEY=' | sed 's/^SIRIUS_API_KEY=//')
curl -i -H "X-API-Key: ${RUNTIME_KEY}" http://localhost:9001/host/   # expect 200

# 6) Ensure startup regressions are absent
docker compose logs --no-color sirius-ui sirius-engine | rg -i "ENOTFOUND|permission denied|Failed to open log file"

If step 6 returns any lines, capture full logs and investigate before rollout.

Release Image Propagation Verification

Use this path to validate what operators experience when running pulled release images.

# 1) Ensure local builds are not used
docker compose down -v --remove-orphans

# 2) Generate runtime secrets/config
docker compose -f docker-compose.installer.yaml run --rm sirius-installer --non-interactive --no-print-secrets

# 3) Pull and run release images for the selected tag
export IMAGE_TAG=v1.0.0
export SIRIUS_IMAGE_PULL_POLICY=always
docker compose up -d

# 4) Verify running container image IDs match pulled release images
bash scripts/verify-release-images.sh

Expected result: all checks print ✅ and no service is running an unexpected local image.

Runtime Auth Contract Verification

Use this check any time you run reset, switch between source/release mode, or see 401 and DB auth errors.

# Validate runtime env parity, stale postgres entrypoint behavior, and auth probes
bash scripts/verify-runtime-auth-contract.sh

If this script fails, do not start new scans until the mismatch is corrected.

If sirius-engine is still restarting after this passes, verify runtime preflight tooling:

docker exec sirius-engine sh -lc 'which psql && psql --version'

Expected result: prints /usr/bin/psql and a PostgreSQL client version. If missing, pull the corrected release image and recreate services.

Scan-Stuck Troubleshooting Runbook

If scans complete in backend logs but UI remains non-terminal, run:

# 0) Do NOT use command-scoped secret overrides for single-service restarts.
# Bad (causes key drift): SIRIUS_API_KEY=local-dev docker compose up -d sirius-engine
# Good: keep secrets in .env and recreate dependent services together.

# 1) Verify API key contract is consistent across services
docker inspect sirius-ui --format '{{range .Config.Env}}{{println .}}{{end}}' | rg '^SIRIUS_API_KEY='
docker inspect sirius-api --format '{{range .Config.Env}}{{println .}}{{end}}' | rg '^SIRIUS_API_KEY='
docker inspect sirius-engine --format '{{range .Config.Env}}{{println .}}{{end}}' | rg '^SIRIUS_API_KEY='

# 2) Check engine scanner warnings and terminal status persistence
docker compose logs --no-color sirius-engine | rg -i "source-aware|status|completed|failed|warning|401"

# 3) Check UI auth/session and API bridge logs
docker compose logs --no-color sirius-ui | rg -i "JWT_SESSION_ERROR|SIRIUS_API_KEY|fetch failed|401"

# 4) Verify DB credential consistency from runtime containers
docker compose logs --no-color sirius-postgres sirius-api sirius-engine | rg -i "password authentication failed|database connection not available"

# 5) Run contract verifier
bash scripts/verify-runtime-auth-contract.sh

# 6) Verify templates endpoint is populated and not in missing/empty state
API_KEY=$(docker inspect sirius-api --format '{{range .Config.Env}}{{println .}}{{end}}' | rg '^SIRIUS_API_KEY=' | sed 's/^SIRIUS_API_KEY=//')
curl -s -D - -o /tmp/sirius-templates.json -H "X-API-Key: ${API_KEY}" http://localhost:9001/templates | rg '^HTTP/|^X-Sirius-Template-State'
python3 -c 'import json; print(len(json.load(open("/tmp/sirius-templates.json"))))'

If any command surfaces key/secret mismatch, re-run installer and restart:

docker compose -f docker-compose.installer.yaml run --rm sirius-installer --non-interactive --no-print-secrets
docker compose up -d --force-recreate

Expected result for step 6: HTTP 200 and template count >= 1. If X-Sirius-Template-State: missing or empty appears, sirius-engine has not initialized template data yet.

🔎 Host Discovery Validation

# Confirm compose renders successfully and includes NET_RAW
SIRIUS_API_KEY=test-key POSTGRES_PASSWORD=test-pass NEXTAUTH_SECRET=test-secret \
INITIAL_ADMIN_PASSWORD=test-admin-pass \
docker compose -f docker-compose.yaml config | rg "NET_RAW"

# Confirm scanner system template is canonicalized on startup (quick includes fingerprint)
docker compose exec sirius-valkey valkey-cli GET template:quick | rg '"scan_types"'

# Run a scan from UI/API, then verify queue consumers and scan state
docker compose exec sirius-rabbitmq rabbitmqctl list_queues name consumers messages_ready messages_unacknowledged | rg "scan|scan_control"
docker compose exec sirius-valkey valkey-cli GET currentScan

🎯 What Can Sirius Do?

Core Capabilities

• 🔍 Network Discovery: Automated host discovery and service enumeration
• 🛡️ Vulnerability Assessment: CVE-based vulnerability detection with CVSS scoring
• 📊 Risk Management: Comprehensive risk scoring and remediation guidance
• 🎪 Visual Scanning Workflows: Drag-and-drop scan configuration
• 🔄 Automated Scanning: Scheduled and continuous security assessments
• 📡 Remote Agent Support: Distributed scanning across multiple environments
• 💻 Interactive Terminal: PowerShell-based command interface for advanced operations
• 📈 Real-time Dashboards: Live scanning progress and vulnerability metrics

Supported Scan Types

• Network Scanning: Nmap-based port and service discovery
• Vulnerability Scanning: NSE script-based vulnerability detection
• SMB/Windows Assessment: Specialized Windows security testing
• Custom Workflows: User-defined scanning configurations
• Agent-based Scanning: Remote endpoint assessment

🏗️ System Architecture

Sirius uses a microservices architecture with the following components:

📡 Service Communication Flow

graph TD
    subgraph clients [Clients]
        UI["Sirius UI (Next.js)"]
        CLI["Terminal and Agent Runtime"]
    end

    subgraph core [Core Services]
        API["Sirius API (Go/Gin)"]
        Engine["Sirius Engine"]
    end

    subgraph infra [Infrastructure]
        MQ["RabbitMQ"]
        DB["PostgreSQL"]
        Cache["Valkey"]
    end

    UI -->|"HTTP/WebSocket"| API
    CLI -->|"gRPC"| Engine
    API -->|"AMQP publish"| MQ
    MQ -->|"Queue consume"| Engine
    API -->|"SQL read/write"| DB
    Engine -->|"SQL read/write"| DB
    API -->|"Session/cache ops"| Cache
    Engine -->|"Scan state cache ops"| Cache

🤖 Agent Runtime Note

• app-agent runs inside sirius-engine in the default deployment.
• The gRPC endpoint is exposed on port 50051.
• You do not need a separate app-agent container for the standard/prod compose flows in this repo.

🗄️ Data Storage

• PostgreSQL: Vulnerability data, scan results, host information
• SQLite: User authentication and session data (development)
• Valkey/Redis: Caching, temporary scan data, session storage
• RabbitMQ: Message queues for scan requests and agent communication

📱 Interface Overview

📊 Dashboard

Your central command center featuring:

• Real-time scanning activity and progress monitoring
• Latest vulnerability discoveries with severity trends
• System performance metrics and resource utilization
• Quick-access controls for common scanning operations
• Executive summary with risk scoring

🔍 Scanning Interface

Advanced scanning capabilities:

• Visual Workflow Editor: Drag-and-drop scan module configuration
• Real-time Progress: Live scan status with detailed logging
• Custom Profiles: Save and reuse scanning configurations
• Scheduled Scans: Automated scanning with cron-like scheduling
• Multi-target Support: Scan multiple hosts, networks, or IP ranges
• NSE Script Integration: Custom Nmap scripts for specialized testing

🎯 Vulnerability Navigator

Comprehensive vulnerability management:

• Dynamic Filtering: Real-time search across all vulnerability data
• Risk Prioritization: CVSS-based severity sorting and filtering
• Detailed Reports: CVE/CPE mapping with remediation guidance
• Export Capabilities: PDF, CSV, and JSON report generation
• Historical Tracking: Vulnerability timeline and remediation progress
• Integration Ready: API endpoints for external security tools

🌐 Environment Overview

Complete infrastructure visibility:

• Asset Inventory: Comprehensive host and service discovery
• Network Topology: Interactive visualization of discovered infrastructure
• Risk Assessment: Environment-wide security posture analysis
• Service Enumeration: Detailed service versioning and configuration
• Compliance Tracking: Security baseline monitoring and reporting

🖥️ Host Details

In-depth system analysis:

• System Profiling: Complete hardware and software inventory
• Port Analysis: Detailed service discovery and version detection
• Security Metrics: Host-specific vulnerability counts and risk scores
• Historical Data: Scan history and security trend analysis
• Remediation Tracking: Fix validation and security improvement monitoring

💻 Terminal Interface

Advanced operations console:

• PowerShell Environment: Full scripting capabilities for automation
• Agent Management: Remote agent deployment and configuration
• Custom Scripts: Execute custom security testing scripts
• Batch Operations: Bulk scanning and management operations
• System Diagnostics: Real-time system health and performance monitoring

🛠️ Standard Setup

Perfect for security professionals and penetration testers:

git clone https://github.com/SiriusScan/Sirius.git
cd Sirius
docker compose -f docker-compose.installer.yaml run --rm sirius-installer
docker compose up -d

This configuration provides:

• ✅ Complete scanning capabilities out-of-the-box
• ✅ Pre-configured vulnerability databases
• ✅ No additional setup required
• ✅ Production-ready security scanning

🤝 Contributing

Want to contribute to Sirius? We welcome contributions from the community!

For Developers: Check out our comprehensive Contributing Guide for:

• 🔧 Development environment setup
• 🔄 Development workflow and best practices
• 🧪 Testing and quality assurance
• 📝 Code standards and Git workflow
• 🚀 Submitting pull requests

Quick Links:

• Development Setup
• Testing Guide
• Code Standards
• GitHub Issues

Join our community and help make security scanning accessible to everyone!

🔌 API & Integration

Sirius provides comprehensive APIs for integration with existing security workflows:

REST API Endpoints

• Sirius exposes REST endpoints on http://localhost:9001.
• The API is protected by SIRIUS_API_KEY middleware.
• Include the API key in requests with X-API-Key: <your key>.

WebSocket APIs

• Real-time Updates: Live scan progress and vulnerability notifications
• Agent Communication: Bidirectional agent management
• System Monitoring: Live system metrics and health status

Integration Examples

# Health endpoint
curl http://localhost:9001/health \
  -H "X-API-Key: $SIRIUS_API_KEY"

# Example authenticated request
curl http://localhost:9001/api/v1/scan/get/all \
  -H "X-API-Key: $SIRIUS_API_KEY"

🔧 Troubleshooting

Common Issues & Solutions

🐳 Container Issues

Problem: Services fail to start

# Diagnosis
docker compose ps              # Check service status
docker compose logs <service>  # View service logs
docker system df              # Check disk space

# Solutions
docker compose -f docker-compose.installer.yaml run --rm sirius-installer  # Ensure required secrets exist in .env
docker compose down && docker compose up -d --build  # Fresh restart
docker system prune -f                               # Clean up space

Problem: Infrastructure services (PostgreSQL, RabbitMQ, Valkey) don't start

# This occurs when using only docker-compose.dev.yaml
# The dev file is an OVERRIDE file, not standalone

# ❌ Wrong (only starts 3 services):
docker compose -f docker-compose.dev.yaml up -d

# ✅ Correct (starts all 6 services):
docker compose -f docker-compose.yaml -f docker-compose.dev.yaml up -d

Problem: "Port already in use" errors

# Find process using port
netstat -tuln | grep 3000
lsof -i :3000

# Solution: Stop conflicting service or change port
docker compose down
# Edit docker-compose.yaml to use different ports if needed

🔍 Scanner Issues

Problem: Nmap errors or scanning failures

# Check scanner logs
docker logs sirius-engine | grep -i nmap

# Test Nmap directly
docker exec sirius-engine nmap --version
docker exec sirius-engine nmap -p 80 127.0.0.1

# Common fixes
docker restart sirius-engine
docker exec sirius-engine which nmap  # Verify Nmap installation

Problem: "Duplicate port specification" warnings

# This is resolved in current version, but if you see it:
docker exec sirius-engine grep -r "port.*specification" /app-scanner-src/
# Should show corrected port ranges like "1-1000,3389"

🗄️ Database Issues

Problem: Database connection failures

# Check PostgreSQL status
docker exec sirius-postgres pg_isready
docker logs sirius-postgres

# Test connection
docker exec sirius-postgres psql -U postgres -d sirius -c "SELECT version();"

# Reset database if needed
docker compose down
docker volume rm sirius_postgres_data
docker compose up -d

🐰 Message Queue Issues

Problem: RabbitMQ connectivity issues

# Check RabbitMQ status
docker exec sirius-rabbitmq rabbitmqctl status

# View queue status
docker exec sirius-rabbitmq rabbitmqctl list_queues

# Access management interface
open http://localhost:15672

Problem: RabbitMQ schema integrity check failed

# This occurs when RabbitMQ has old data from an incompatible version
# Solution: Remove old volumes and restart fresh

docker compose down -v  # For standard setup
# Or for development:
docker compose -f docker-compose.yaml -f docker-compose.dev.yaml down -v
docker compose -f docker-compose.yaml -f docker-compose.dev.yaml up -d

🌐 Network & Connectivity

Problem: Services can't communicate

# Test internal network
docker exec sirius-ui ping sirius-api
docker exec sirius-api ping sirius-postgres

# Check network configuration
docker network ls
docker network inspect sirius

Problem: External access issues

# Verify port mapping
docker port sirius-ui
docker port sirius-api

# Check firewall (Linux)
sudo ufw status
sudo iptables -L

# Check firewall (macOS)
sudo pfctl -s all

🚨 Emergency Recovery

Complete System Reset:

# Stop all services
docker compose down

# Remove all data (⚠️ This deletes all scan data!)
docker compose down -v

# Clean Docker system
docker system prune -a -f

# Recreate .env using installer (required after reset)
docker compose -f docker-compose.installer.yaml run --rm sirius-installer --non-interactive --no-print-secrets

# Fresh start without shell variable shadowing
env -u SIRIUS_API_KEY -u POSTGRES_PASSWORD -u NEXTAUTH_SECRET -u INITIAL_ADMIN_PASSWORD \
SIRIUS_IMAGE_PULL_POLICY=never docker compose up -d --build

# Verify auth contract before interacting with UI
bash scripts/verify-runtime-auth-contract.sh

Backup Current Data:

# Backup database
docker exec sirius-postgres pg_dump -U postgres sirius > backup.sql

# Backup scan results directory
docker cp sirius-engine:/opt/sirius/ ./sirius-backup/

🔒 Security Best Practices

🏭 Production Deployment

Essential Security Steps:

1. Change Default Credentials:

# Generate secure values with the installer
docker compose -f docker-compose.installer.yaml run --rm sirius-installer --force

# Or set explicit values in .env if needed
# POSTGRES_PASSWORD=your_secure_password
# NEXTAUTH_SECRET=your_long_random_secret
# SIRIUS_API_KEY=your_long_random_api_key
# INITIAL_ADMIN_PASSWORD=your_strong_admin_password

2. Network Security:

# Use internal networks for service communication
# Expose only necessary ports (3000 for UI)
# Configure firewall rules
sudo ufw allow 3000/tcp
sudo ufw deny 5432/tcp  # Don't expose database

3. SSL/TLS Configuration:

# Use reverse proxy with SSL (nginx/traefik)
# Enable HTTPS for web interface
# Secure API endpoints with proper certificates

4. Data Protection:

# Encrypt database backups
# Secure volume mounts
# Regular security updates
docker compose pull  # Update images regularly

🛡️ Security Scanning Best Practices

• Network Isolation: Run scans from isolated networks when possible
• Permission Management: Use least-privilege principles for scan accounts
• Scan Scheduling: Perform intensive scans during maintenance windows
• Data Retention: Implement appropriate data lifecycle policies
• Audit Logging: Enable comprehensive logging for compliance

📚 Documentation & Resources

📖 Essential Documentation

• 📘 Installation Guide - Detailed setup instructions
• 🎯 Quick Start Guide - Get scanning in 5 minutes
• 🎪 Interface Tour - Complete UI walkthrough
• 🔧 Configuration Guide - Advanced configuration options
• 🛡️ Security Guide - Production security best practices

🔌 Technical Documentation

• 🚀 API Reference - Complete API documentation
• 📦 Go SDK - Go integration library
• 🐳 Docker Guide - Comprehensive Docker documentation
• 🏗️ Architecture Guide - System architecture deep-dive
• 🔄 CI/CD Guide - Deployment automation

🎓 User Guides

• 🔍 Scanning Guide - Advanced scanning techniques
• 🎯 Vulnerability Management - Managing discovered vulnerabilities
• 🌐 Environment Management - Infrastructure assessment
• 🖥️ Host Management - Individual host analysis
• 💻 Terminal Guide - Advanced PowerShell operations

🤝 Community & Support

• ❓ FAQ - Frequently asked questions
• 🐛 GitHub Issues - Bug reports and feature requests
• 💬 Discord Community - Real-time community support
• 🤝 Contributing Guide - How to contribute to Sirius
• 📧 Support Contact - Direct technical support

📊 Performance & Scaling

📈 System Requirements by Use Case

⚡ Performance Optimization

# Monitor resource usage
docker stats

# Optimize for large environments
# Edit docker-compose.yaml and add:
services:
  sirius-engine:
    deploy:
      resources:
        limits:
          cpus: '4.0'
          memory: 8G
        reservations:
          cpus: '2.0'
          memory: 4G

🆕 What's New

Recent Updates

• ✅ Fixed Nmap Configuration: Resolved duplicate port specification warnings
• ✅ Enhanced Development Mode: Improved volume mounting for local development
• ✅ Better Error Handling: Enhanced debugging and logging capabilities
• ✅ Performance Improvements: Optimized container startup and resource usage
• ✅ Security Enhancements: Updated default configurations and security practices

Upcoming Features

• 🔄 Advanced Reporting: Enhanced PDF and dashboard reporting
• 🎯 AI-Powered Analysis: Automated vulnerability risk assessment
• 📱 Mobile Support: Mobile-responsive interface improvements
• 🔌 Plugin System: Extensible scanning module architecture
• ☁️ Cloud Integration: Native cloud platform scanning support

📄 License

This project is licensed under the terms specified in the LICENSE file.

🚀 Ready to start scanning? Follow our Quick Start Guide and have Sirius running in under 5 minutes!

💡 Need help? Join our Discord community for real-time support and discussion.

🐛 Found a bug? Report it on GitHub Issues - we respond quickly!

For production deployments, always change default credentials and review our Security Guide for best practices.