main.go

package main

import (
	"bufio"
	"context"
	"encoding/hex"
	"fmt"
	"log"
	"net"
	"net/http"
	"net/url"
	"os"
	"strconv"
	"strings"
	"sync"
	"time"

	"github.com/gotd/td/telegram"
	"github.com/gotd/td/telegram/dcs"
)

const (
	API_ID   = 6
	API_HASH = "eb06d4abfb49dc3eeb1aeb98ae0f581e"

	PROXY_SOURCE = "https://raw.githubusercontent.com/SoliSpirit/mtproto/refs/heads/master/all_proxies.txt"
	OUTPUT_FILE  = "output.txt"

	TIMEOUT     = 4 * time.Second
	CONCURRENCY = 100
)

type Proxy struct {
	Server   string
	Port     int
	Secret   string
	Original string
}

func parseProxy(line string) *Proxy {
	line = strings.TrimSpace(line)
	if !strings.Contains(line, "://") {
		return nil
	}

	u, err := url.Parse(line)
	if err != nil {
		return nil
	}

	q := u.Query()
	server := q.Get("server")
	secret := q.Get("secret")
	portStr := q.Get("port")

	if server == "" || secret == "" || portStr == "" {
		return nil
	}

	if len(secret) < 32 || len(secret) > 170 {
		return nil
	}

	port, err := strconv.Atoi(portStr)
	if err != nil || port <= 0 || port > 65535 {
		return nil
	}

	return &Proxy{
		Server:   server,
		Port:     port,
		Secret:   secret,
		Original: line,
	}
}

func checkProxy(p *Proxy) bool {
	addr := net.JoinHostPort(p.Server, strconv.Itoa(p.Port))

	secretBytes, err := hex.DecodeString(p.Secret)
	if err != nil {
		return false
	}

	resolver, err := dcs.MTProxy(addr, secretBytes, dcs.MTProxyOptions{})
	if err != nil {
		return false
	}

	client := telegram.NewClient(API_ID, API_HASH, telegram.Options{
		Resolver: resolver,
	})

	ctx, cancel := context.WithTimeout(context.Background(), TIMEOUT)
	defer cancel()

	err = client.Run(ctx, func(ctx context.Context) error {
		_, err := client.API().HelpGetConfig(ctx)
		return err
	})

	return err == nil
}

func fetchProxies() ([]*Proxy, error) {
	resp, err := http.Get(PROXY_SOURCE)
	if err != nil {
		return nil, err
	}
	defer resp.Body.Close()

	scanner := bufio.NewScanner(resp.Body)
	proxies := make([]*Proxy, 0)

	for scanner.Scan() {
		if p := parseProxy(scanner.Text()); p != nil {
			proxies = append(proxies, p)
		}
	}

	return proxies, scanner.Err()
}

func main() {
	start := time.Now()
	log.Println("Fetching proxy list...")

	proxies, err := fetchProxies()
	if err != nil {
		log.Fatal(err)
	}

	log.Printf("Loaded %d proxies\n", len(proxies))

	out, err := os.Create(OUTPUT_FILE)
	if err != nil {
		log.Fatal(err)
	}
	defer out.Close()

	writer := bufio.NewWriter(out)
	defer writer.Flush()

	var wg sync.WaitGroup
	var mu sync.Mutex

	sem := make(chan struct{}, CONCURRENCY)

	var checked, working int

	for _, p := range proxies {
		wg.Add(1)
		go func(p *Proxy) {
			defer wg.Done()
			sem <- struct{}{}
			defer func() { <-sem }()

			if checkProxy(p) {
				mu.Lock()
				writer.WriteString(p.Original + "\n")
				working++
				mu.Unlock()
			}

			mu.Lock()
			checked++
			if checked%100 == 0 {
				log.Printf("Checking: %d | Working: %d\r", checked, working)
			}
			mu.Unlock()
		}(p)
	}

	wg.Wait()

	fmt.Println()
	log.Printf("Done in %s", time.Since(start))
	log.Printf("Working proxies: %d", working)
	log.Printf("Saved to %s", OUTPUT_FILE)
}