myaidev-method 0.2.19 → 0.2.22

package/src/scripts/openstack-setup.sh

@@ -0,0 +1,110 @@
+#!/bin/bash
+# OpenStack Setup Helper Script
+# This script helps configure OpenStack credentials for the MyAIDev Method
+
+set -e
+
+echo "================================"
+echo "OpenStack Configuration Helper"
+echo "================================"
+echo ""
+
+# Check if OpenStack CLI is installed
+if ! command -v openstack &> /dev/null; then
+    echo "OpenStack CLI is not installed."
+    echo ""
+    echo "To install on Ubuntu/Debian:"
+    echo "  sudo apt update"
+    echo "  sudo apt install python3-openstackclient"
+    echo ""
+    echo "To install with pip:"
+    echo "  pip install python-openstackclient"
+    echo ""
+    echo "After installation, re-run this script."
+    exit 1
+fi
+
+echo "OpenStack CLI found: $(which openstack)"
+echo "Version: $(openstack --version 2>&1)"
+echo ""
+
+# Check for openrc file
+OPENRC_FILE="${1:-openrc}"
+
+if [ -f "$OPENRC_FILE" ]; then
+    echo "Found openrc file: $OPENRC_FILE"
+    echo ""
+    echo "Parsing environment variables..."
+
+    # Parse the openrc file (without executing it for security)
+    OS_AUTH_URL=$(grep -E "^export OS_AUTH_URL=" "$OPENRC_FILE" | cut -d'=' -f2- | tr -d '"' | tr -d "'")
+    OS_USERNAME=$(grep -E "^export OS_USERNAME=" "$OPENRC_FILE" | cut -d'=' -f2- | tr -d '"' | tr -d "'")
+    OS_PROJECT_ID=$(grep -E "^export OS_PROJECT_ID=" "$OPENRC_FILE" | cut -d'=' -f2- | tr -d '"' | tr -d "'")
+    OS_USER_DOMAIN_ID=$(grep -E "^export OS_USER_DOMAIN_ID=" "$OPENRC_FILE" | cut -d'=' -f2- | tr -d '"' | tr -d "'" || echo "default")
+    OS_PROJECT_DOMAIN_ID=$(grep -E "^export OS_PROJECT_DOMAIN_ID=" "$OPENRC_FILE" | cut -d'=' -f2- | tr -d '"' | tr -d "'" || echo "default")
+    OS_REGION_NAME=$(grep -E "^export OS_REGION_NAME=" "$OPENRC_FILE" | cut -d'=' -f2- | tr -d '"' | tr -d "'")
+
+    echo "Detected configuration:"
+    echo "  Auth URL: $OS_AUTH_URL"
+    echo "  Username: $OS_USERNAME"
+    echo "  Project ID: $OS_PROJECT_ID"
+    echo "  User Domain: ${OS_USER_DOMAIN_ID:-default}"
+    echo "  Project Domain: ${OS_PROJECT_DOMAIN_ID:-default}"
+    echo "  Region: $OS_REGION_NAME"
+    echo ""
+
+    # Check if .env exists
+    ENV_FILE=".env"
+    if [ -f "$ENV_FILE" ]; then
+        echo "Existing .env file found. Will append OpenStack variables."
+    fi
+
+    echo "Enter your OpenStack password:"
+    read -sr OS_PASSWORD
+    echo ""
+
+    # Write to .env file
+    {
+        echo ""
+        echo "# OpenStack Configuration"
+        echo "OS_AUTH_URL=$OS_AUTH_URL"
+        echo "OS_USERNAME=$OS_USERNAME"
+        echo "OS_PASSWORD=$OS_PASSWORD"
+        echo "OS_PROJECT_ID=$OS_PROJECT_ID"
+        echo "OS_USER_DOMAIN_ID=${OS_USER_DOMAIN_ID:-default}"
+        echo "OS_PROJECT_DOMAIN_ID=${OS_PROJECT_DOMAIN_ID:-default}"
+        echo "OS_REGION_NAME=$OS_REGION_NAME"
+        echo "OS_IDENTITY_API_VERSION=3"
+    } >> "$ENV_FILE"
+
+    echo "Configuration written to $ENV_FILE"
+    echo ""
+
+    # Test the connection
+    echo "Testing OpenStack connection..."
+    source "$OPENRC_FILE"
+    export OS_PASSWORD
+
+    if openstack token issue &> /dev/null; then
+        echo "Connection successful!"
+    else
+        echo "Connection failed. Please verify your credentials."
+        exit 1
+    fi
+
+else
+    echo "No openrc file found at: $OPENRC_FILE"
+    echo ""
+    echo "Usage: $0 [path/to/openrc]"
+    echo ""
+    echo "You can download your openrc file from your OpenStack dashboard:"
+    echo "  1. Log in to your OpenStack dashboard"
+    echo "  2. Go to Project > API Access"
+    echo "  3. Click 'Download OpenStack RC File'"
+    echo ""
+fi
+
+echo ""
+echo "================================"
+echo "Setup Complete"
+echo "================================"

package/src/scripts/security/environment-detect.js

@@ -0,0 +1,425 @@
+#!/usr/bin/env node
+
+/**
+ * MyAIDev Method - Security Environment Detection
+ *
+ * Detects execution environment and recommends setup approach
+ * @module security/environment-detect
+ */
+
+import { execSync } from 'child_process';
+import fs from 'fs';
+
+/**
+ * Environment types
+ */
+const EnvType = {
+  KALI_NATIVE: 'kali_native',
+  KALI_DOCKER: 'kali_docker',
+  UBUNTU_NATIVE: 'ubuntu_native',
+  DEBIAN_NATIVE: 'debian_native',
+  FEDORA_NATIVE: 'fedora_native',
+  DOCKER_CONTAINER: 'docker_container',
+  UNKNOWN: 'unknown'
+};
+
+/**
+ * Environment detection class
+ */
+class EnvironmentDetector {
+  constructor() {
+    this.osInfo = {};
+    this.containerInfo = {};
+    this.toolsInfo = {};
+  }
+
+  /**
+   * Detect execution environment
+   */
+  async detect() {
+    console.log('🔍 Detecting security testing environment...\n');
+
+    // Detect OS
+    this.detectOS();
+
+    // Detect container environment
+    this.detectContainer();
+
+    // Check Docker availability
+    this.detectDocker();
+
+    // Check existing tools
+    this.detectTools();
+
+    // Generate recommendation
+    const recommendation = this.generateRecommendation();
+
+    // Display results
+    this.displayResults(recommendation);
+
+    return {
+      os: this.osInfo,
+      container: this.containerInfo,
+      tools: this.toolsInfo,
+      recommendation
+    };
+  }
+
+  /**
+   * Detect operating system
+   */
+  detectOS() {
+    try {
+      // Check if /etc/os-release exists
+      if (fs.existsSync('/etc/os-release')) {
+        const osRelease = fs.readFileSync('/etc/os-release', 'utf8');
+
+        // Parse OS release file
+        const lines = osRelease.split('\n');
+        for (const line of lines) {
+          const [key, value] = line.split('=');
+          if (value) {
+            this.osInfo[key] = value.replace(/"/g, '');
+          }
+        }
+
+        // Determine OS type
+        const id = this.osInfo.ID || '';
+        if (id.includes('kali')) {
+          this.osInfo.type = EnvType.KALI_NATIVE;
+        } else if (id.includes('ubuntu')) {
+          this.osInfo.type = EnvType.UBUNTU_NATIVE;
+        } else if (id.includes('debian')) {
+          this.osInfo.type = EnvType.DEBIAN_NATIVE;
+        } else if (id.includes('fedora') || id.includes('rhel') || id.includes('centos')) {
+          this.osInfo.type = EnvType.FEDORA_NATIVE;
+        } else {
+          this.osInfo.type = EnvType.UNKNOWN;
+        }
+      }
+
+      // Get kernel version
+      try {
+        this.osInfo.kernel = execSync('uname -r', { encoding: 'utf8' }).trim();
+      } catch (err) {
+        this.osInfo.kernel = 'unknown';
+      }
+
+      // Detect package manager
+      if (this.commandExists('apt')) {
+        this.osInfo.packageManager = 'apt';
+      } else if (this.commandExists('dnf')) {
+        this.osInfo.packageManager = 'dnf';
+      } else if (this.commandExists('yum')) {
+        this.osInfo.packageManager = 'yum';
+      } else if (this.commandExists('pacman')) {
+        this.osInfo.packageManager = 'pacman';
+      } else {
+        this.osInfo.packageManager = 'unknown';
+      }
+
+    } catch (err) {
+      console.error('Error detecting OS:', err.message);
+      this.osInfo.type = EnvType.UNKNOWN;
+    }
+  }
+
+  /**
+   * Detect container environment
+   */
+  detectContainer() {
+    try {
+      // Check for /.dockerenv
+      if (fs.existsSync('/.dockerenv')) {
+        this.containerInfo.isContainer = true;
+        this.containerInfo.type = 'docker';
+        return;
+      }
+
+      // Check cgroup for docker/container
+      if (fs.existsSync('/proc/1/cgroup')) {
+        const cgroup = fs.readFileSync('/proc/1/cgroup', 'utf8');
+        if (cgroup.includes('docker')) {
+          this.containerInfo.isContainer = true;
+          this.containerInfo.type = 'docker';
+          return;
+        }
+        if (cgroup.includes('kubepods')) {
+          this.containerInfo.isContainer = true;
+          this.containerInfo.type = 'kubernetes';
+          return;
+        }
+      }
+
+      this.containerInfo.isContainer = false;
+    } catch (err) {
+      this.containerInfo.isContainer = false;
+    }
+  }
+
+  /**
+   * Detect Docker availability
+   */
+  detectDocker() {
+    try {
+      if (this.commandExists('docker')) {
+        const version = execSync('docker --version', { encoding: 'utf8' }).trim();
+        this.containerInfo.dockerAvailable = true;
+        this.containerInfo.dockerVersion = version;
+
+        // Check if Docker daemon is running
+        try {
+          execSync('docker ps', { encoding: 'utf8', stdio: 'ignore' });
+          this.containerInfo.dockerRunning = true;
+        } catch (err) {
+          this.containerInfo.dockerRunning = false;
+        }
+      } else {
+        this.containerInfo.dockerAvailable = false;
+      }
+    } catch (err) {
+      this.containerInfo.dockerAvailable = false;
+    }
+  }
+
+  /**
+   * Detect existing security tools
+   */
+  detectTools() {
+    const essentialTools = [
+      'nmap',
+      'masscan',
+      'sqlmap',
+      'nikto',
+      'hydra',
+      'john',
+      'hashcat',
+      'metasploit-framework',
+      'burpsuite',
+      'zaproxy'
+    ];
+
+    const commandMap = {
+      'metasploit-framework': 'msfconsole',
+      'burpsuite': 'burpsuite',
+      'zaproxy': 'zaproxy'
+    };
+
+    const installed = [];
+    const missing = [];
+
+    for (const tool of essentialTools) {
+      const command = commandMap[tool] || tool;
+      if (this.commandExists(command)) {
+        installed.push(tool);
+      } else {
+        missing.push(tool);
+      }
+    }
+
+    this.toolsInfo.installed = installed;
+    this.toolsInfo.missing = missing;
+    this.toolsInfo.installCount = installed.length;
+    this.toolsInfo.totalCount = essentialTools.length;
+    this.toolsInfo.percentInstalled = Math.round((installed.length / essentialTools.length) * 100);
+  }
+
+  /**
+   * Check if command exists
+   */
+  commandExists(command) {
+    try {
+      execSync(`which ${command}`, { stdio: 'ignore' });
+      return true;
+    } catch (err) {
+      return false;
+    }
+  }
+
+  /**
+   * Generate setup recommendation
+   */
+  generateRecommendation() {
+    const rec = {
+      approach: '',
+      reason: '',
+      steps: [],
+      estimatedTime: '',
+      diskSpace: ''
+    };
+
+    // If already Kali Linux
+    if (this.osInfo.type === EnvType.KALI_NATIVE) {
+      rec.approach = 'verify_tools';
+      rec.reason = 'Kali Linux detected - most tools pre-installed';
+      rec.steps = [
+        'Update package lists: sudo apt update',
+        'Upgrade packages: sudo apt upgrade',
+        'Verify tool installations',
+        'Install any missing tools'
+      ];
+      rec.estimatedTime = '10-15 minutes';
+      rec.diskSpace = '~500MB';
+      return rec;
+    }
+
+    // If Kali Docker available
+    if (this.containerInfo.dockerAvailable && this.containerInfo.dockerRunning) {
+      rec.approach = 'kali_docker';
+      rec.reason = 'Docker available - isolated environment recommended';
+      rec.steps = [
+        'Pull Kali Linux Docker image',
+        'Create persistent volume',
+        'Start Kali container with capabilities',
+        'Install kali-linux-default package',
+        'Verify tool installations'
+      ];
+      rec.estimatedTime = '20-30 minutes';
+      rec.diskSpace = '~3GB';
+      return rec;
+    }
+
+    // If Docker available but not running
+    if (this.containerInfo.dockerAvailable && !this.containerInfo.dockerRunning) {
+      rec.approach = 'kali_docker';
+      rec.reason = 'Docker installed but not running';
+      rec.steps = [
+        'Start Docker service: sudo systemctl start docker',
+        'Pull Kali Linux Docker image',
+        'Create persistent volume',
+        'Start Kali container',
+        'Install security tools'
+      ];
+      rec.estimatedTime = '25-35 minutes';
+      rec.diskSpace = '~3GB';
+      return rec;
+    }
+
+    // Native installation (no Docker)
+    if (this.osInfo.type === EnvType.UBUNTU_NATIVE ||
+        this.osInfo.type === EnvType.DEBIAN_NATIVE) {
+      rec.approach = 'native_install';
+      rec.reason = 'Native Linux installation - direct tool installation';
+      rec.steps = [
+        'Update package lists',
+        'Install network scanning tools (nmap, masscan)',
+        'Install web testing tools (sqlmap, nikto)',
+        'Install exploitation tools (metasploit)',
+        'Install password tools (john, hashcat, hydra)',
+        'Verify installations'
+      ];
+      rec.estimatedTime = '45-60 minutes';
+      rec.diskSpace = '~2GB';
+      return rec;
+    }
+
+    // Fedora/RHEL/CentOS
+    if (this.osInfo.type === EnvType.FEDORA_NATIVE) {
+      rec.approach = 'native_install';
+      rec.reason = 'Fedora/RHEL system - native installation with DNF';
+      rec.steps = [
+        'Enable EPEL repository',
+        'Update system: sudo dnf update',
+        'Install security tools via DNF',
+        'Install remaining tools from source',
+        'Verify installations'
+      ];
+      rec.estimatedTime = '45-60 minutes';
+      rec.diskSpace = '~2GB';
+      return rec;
+    }
+
+    // Fallback - recommend Docker
+    rec.approach = 'install_docker_first';
+    rec.reason = 'Unknown environment - Docker installation recommended';
+    rec.steps = [
+      'Install Docker: curl -fsSL https://get.docker.com | sh',
+      'Start Docker service',
+      'Follow Kali Docker setup',
+      'Install security tools in container'
+    ];
+    rec.estimatedTime = '30-45 minutes';
+    rec.diskSpace = '~3.5GB';
+    return rec;
+  }
+
+  /**
+   * Display detection results
+   */
+  displayResults(recommendation) {
+    console.log('═══════════════════════════════════════════════════════');
+    console.log('🔍 Environment Detection Results');
+    console.log('═══════════════════════════════════════════════════════\n');
+
+    // OS Information
+    console.log('📋 Operating System:');
+    console.log(`   Name: ${this.osInfo.NAME || 'Unknown'}`);
+    console.log(`   Version: ${this.osInfo.VERSION || 'Unknown'}`);
+    console.log(`   ID: ${this.osInfo.ID || 'Unknown'}`);
+    console.log(`   Kernel: ${this.osInfo.kernel || 'Unknown'}`);
+    console.log(`   Package Manager: ${this.osInfo.packageManager || 'Unknown'}\n`);
+
+    // Container Information
+    console.log('🐳 Container Environment:');
+    console.log(`   Running in Container: ${this.containerInfo.isContainer ? 'Yes' : 'No'}`);
+    if (this.containerInfo.isContainer) {
+      console.log(`   Container Type: ${this.containerInfo.type}`);
+    }
+    console.log(`   Docker Available: ${this.containerInfo.dockerAvailable ? 'Yes' : 'No'}`);
+    if (this.containerInfo.dockerAvailable) {
+      console.log(`   Docker Version: ${this.containerInfo.dockerVersion}`);
+      console.log(`   Docker Running: ${this.containerInfo.dockerRunning ? 'Yes' : 'No'}`);
+    }
+    console.log();
+
+    // Security Tools
+    console.log('🛠️  Security Tools:');
+    console.log(`   Installed: ${this.toolsInfo.installCount}/${this.toolsInfo.totalCount} (${this.toolsInfo.percentInstalled}%)`);
+    if (this.toolsInfo.installed.length > 0) {
+      console.log(`   Found: ${this.toolsInfo.installed.slice(0, 5).join(', ')}${this.toolsInfo.installed.length > 5 ? '...' : ''}`);
+    }
+    console.log();
+
+    // Recommendation
+    console.log('═══════════════════════════════════════════════════════');
+    console.log('📋 Recommended Setup Approach');
+    console.log('═══════════════════════════════════════════════════════\n');
+    console.log(`✨ Approach: ${recommendation.approach.toUpperCase().replace(/_/g, ' ')}`);
+    console.log(`📝 Reason: ${recommendation.reason}`);
+    console.log(`⏱️  Estimated Time: ${recommendation.estimatedTime}`);
+    console.log(`💾 Disk Space: ${recommendation.diskSpace}\n`);
+
+    console.log('📝 Setup Steps:');
+    recommendation.steps.forEach((step, index) => {
+      console.log(`   ${index + 1}. ${step}`);
+    });
+    console.log();
+
+    console.log('═══════════════════════════════════════════════════════\n');
+  }
+}
+
+/**
+ * Main execution
+ */
+async function main() {
+  const detector = new EnvironmentDetector();
+  const result = await detector.detect();
+
+  // Save results to JSON for programmatic use
+  const outputPath = '/tmp/security-env-detect.json';
+  fs.writeFileSync(outputPath, JSON.stringify(result, null, 2));
+  console.log(`📄 Results saved to: ${outputPath}\n`);
+
+  process.exit(0);
+}
+
+// Run if executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main().catch(err => {
+    console.error('❌ Error:', err.message);
+    process.exit(1);
+  });
+}
+
+export { EnvironmentDetector, EnvType };