Получаем десятки тысяч доменов в минуту на шести строчках кода

package main

import (
    "bufio"
    "fmt"
    "io"
    "net/http"
    "net/url"
    "os"
    "regexp"
    "strings"
    "time"
)

func main() {
    const delay = 10 * time.Second

    client := &http.Client{
        CheckRedirect: func(req *http.Request, via []*http.Request) error {
            if len(via) > 0 {
                fmt.Printf("🔁 Редирект с %s на %s\n", via[len(via)-1].URL, req.URL)
            }
            return nil
        },
    }

    file, err := os.Open("links.txt")
    if err != nil {
        fmt.Printf("❌ Ошибка при открытии links.txt: %v\n", err)
        return
    }
    defer file.Close()

    scanner := bufio.NewScanner(file)
    for scanner.Scan() {
        baseURL := strings.TrimSpace(scanner.Text())
        if baseURL == "" {
            continue
        }

        parsed, err := url.Parse(baseURL)
        if err != nil {
            fmt.Printf("⚠️  Невалидный URL %s: %v\n", baseURL, err)
            continue
        }

        segments := strings.Split(strings.Trim(parsed.Path, "/"), "/")
        category := segments[len(segments)-1]
        if category == "" && len(segments) > 1 {
            category = segments[len(segments)-2]
        }

        filename := category + ".txt"
        output, err := os.Create(filename)
        if err != nil {
            fmt.Printf("❌ Не удалось создать файл %s: %v\n", filename, err)
            continue
        }
        defer output.Close()

        fmt.Printf("📂 Обработка категории: %s\n", category)

        page := 1
        for {
            pageURL := fmt.Sprintf("%s?p=%d", baseURL, page)
            fmt.Printf("🌐 Загружаем: %s\n", pageURL)

            req, err := http.NewRequest("GET", pageURL, nil)
            if err != nil {
                fmt.Printf("⚠️  Ошибка создания запроса: %v\n", err)
                break
            }

            resp, err := client.Do(req)
            if err != nil {
                fmt.Printf("⚠️  Ошибка при выполнении запроса: %v\n", err)
                break
            }

            bodyBytes, err := io.ReadAll(resp.Body)
            resp.Body.Close()
            if err != nil {
                fmt.Printf("⚠️  Ошибка чтения тела: %v\n", err)
                break
            }

            body := string(bodyBytes)

            if strings.Contains(body, "&s=n") {
                fmt.Println("🚧 Достигнут конец категории (найдено '&s=n')")
                break
            }

            re := regexp.MustCompile(`<div\s+class="vie_flex_url">.*?<a[^>]+href="(https?://[^"]+)"`)
            matches := re.FindAllStringSubmatch(body, -1)

            if len(matches) == 0 {
                fmt.Println("⚠️  Нет <div class=\"vie_flex_url\"> на странице.")
            }

            for _, m := range matches {
                link := m[1]
                fmt.Fprintf(output, "%s\n", link)
                fmt.Printf("✅ Найдена ссылка: %s\n", link)
            }

            page++
            fmt.Printf("⏳ Пауза %v...\n", delay)
            time.Sleep(delay)
        }
        fmt.Printf("✅ Завершено: %s\n\n", filename)
    }

    if err := scanner.Err(); err != nil {
        fmt.Printf("❌ Ошибка при чтении links.txt: %v\n", err)
    }
}

        import requests

import base64

from cryptography import x509

from cryptography.hazmat.backends import default_backend


def parse_extra_data(extra_data: bytes):

    certs = []

    i = 0

    while i < len(extra_data):

        if i + 3 > len(extra_data):

            break

        cert_len = int.from_bytes(extra_data[i:i+3], "big")

        i += 3

        cert_bytes = extra_data[i:i+cert_len]

        i += cert_len

        certs.append(cert_bytes)

    return certs


url = "https://ct.googleapis.com/logs/us1/argon2025h2/ct/v1/get-entries?start=1000&end=10000"

resp = requests.get(url).json()


for entry in resp["entries"]:

    extra_data = base64.b64decode(entry["extra_data"])

    for cert_bytes in parse_extra_data(extra_data):

        try:

            cert = x509.load_der_x509_certificate(cert_bytes, default_backend())

            domains = []

            try:

                ext = cert.extensions.get_extension_for_class(x509.SubjectAlternativeName)

                domains = ext.value.get_values_for_type(x509.DNSName)

            except Exception:

                pass

            print("CN:", cert.subject.rfc4514_string(), "Domains:", domains)

        except Exception:

            continue