gistfile1.txt

package main

import (
	"bufio"
	"crypto/tls"
	"fmt"
	"log"
	"net"
	"os"
	"strings"
	"sync"
	"time"
)

type WordLists struct {
	Subdomain, Port []string
}

var (
	saveEveryN int = 500
	wg         sync.WaitGroup
	TLSConfig  tls.Config
	SP         *WordLists
)

var Pop = WordLists{
	Subdomain: []string{
		"",
		"pop",
		"pop3",
		"pop.mail",
		"pop-mail",
	},
	Port: []string{
		"995",
		"110",
	},
}

var Imap = WordLists{
	Subdomain: []string{
		"",
		"imap",
		"imap.mail",
		"imap-mail",
	},
	Port: []string{
		"993",
		"143",
	},
}

var SMTP = WordLists{
	Subdomain: []string{
		"",
		"smtp",
		"smtp-mail",
		"smtp.mail",
	},
	Port: []string{
		"465",
		"587",
		"25",
		"2525",
	},
}

func main() {
	args := os.Args[1:]
	if len(args) < 2 {
		fmt.Println("not command and/or file")
		return
	}
	switch args[0] {
	case "filter":
		Filter(args[1])
		return
	case "pop":
		SP = &Pop
		Lookup(args)
	case "imap":
		SP = &Imap
		Lookup(args)
	case "smtp":
		SP = &SMTP
		Lookup(args)
	default:
		os.Exit(1)
	}
}

func Filter(file string) {
	fileByte, err := os.ReadFile(file)
	if err != nil {
		log.Fatal(err)
	}
	lists := strings.Fields(strings.ToLower(string(fileByte)))
	var res struct {
		mu        sync.Mutex
		count     int
		resBuffer *bufio.Writer
	}
	timenow := time.Now().Format("20060102-150405")
	resName := "alive-" + timenow + ".txt"
	resFile, err := os.Create(resName)
	if err != nil {
		log.Fatal(err)
	}
	defer resFile.Close()
	res.resBuffer = bufio.NewWriter(resFile)
	wg.Add(len(lists))
	for _, urlS := range lists {
		go func(url string) {
			if _, err := net.ResolveTCPAddr("tcp4",
				url+":80"); err == nil {
				res.mu.Lock()
				if res.count%saveEveryN == 0 {
					res.resBuffer.Flush()
				}
				log.Println("alive:", url)
				res.resBuffer.WriteString(url + "\n")
				res.count++
				res.mu.Unlock()
			}
			wg.Done()
		}(urlS)
	}
	wg.Wait()
	if res.count == 0 {
		log.Println("empty")
		os.Exit(1)
	}
	log.Println("counts:", res.count)
	log.Println("saved in", resName)
	res.resBuffer.Flush()
}

func initTLS() {
	Cert, err := tls.LoadX509KeyPair("cert.pem", "key.pem")
	if err != nil {
		log.Fatal(err)
	}
	TLSConfig = tls.Config{
		Certificates:       []tls.Certificate{Cert},
		InsecureSkipVerify: true,
	}
}

func Lookup(args []string) {
	initTLS()
	name := args[0]
	file := args[1]
	fileByte, err := os.ReadFile(file)
	if err != nil {
		log.Fatal(err)
	}
	lists := strings.Fields(strings.ToLower(string(fileByte)))
	var res struct {
		mu        sync.Mutex
		count     int
		resBuffer *bufio.Writer
	}
	timenow := time.Now().Format("20060102-150405")
	resName := name + "-" + timenow + ".txt"
	resFile, err := os.Create(resName)
	if err != nil {
		log.Fatal(err)
	}
	defer resFile.Close()
	res.resBuffer = bufio.NewWriter(resFile)
	wg.Add(len(lists))
	for _, urlB := range lists {
		go func(url string) {
			var f bool
			for _, port := range SP.Port {
				for _, subdomain := range SP.Subdomain {
					addr := url + ":" + port
					if subdomain != "" {
						addr = subdomain + "." + addr
					}
					if handshake(addr) {
						res.mu.Lock()
						if res.count%saveEveryN == 0 {
							res.resBuffer.Flush()
						}
						log.Println(name+":", addr)
						res.resBuffer.WriteString(addr + "\n")
						res.count++
						res.mu.Unlock()
						f = true
					}
					if f {
						break
					}
				}
				if f {
					break
				}
			}
			wg.Done()
		}(urlB)
	}
	wg.Wait()
	if res.count == 0 {
		log.Println("empty")
		os.Exit(1)
	}
	log.Println("counts:", res.count)
	log.Println("saved in", resName)
	res.resBuffer.Flush()
}

func handshake(addr string) bool {
	tcpAddr, err := net.ResolveTCPAddr("tcp4", addr)
	if err != nil {
		return false
	}
	conn, err := tls.Dial("tcp4", tcpAddr.String(), &TLSConfig)
	if err != nil {
		return false
	}
	defer conn.Close()
	err = conn.Handshake()
	if err != nil {
		return false
	}
	return true
}