durnkb0t/sh0rtbus.go

341 lines
10 KiB
Go
Raw Normal View History

2020-12-08 01:38:57 +00:00
package main
import (
"fmt"
"strconv"
"strings"
"encoding/base64"
"bytes"
"os"
"io"
// "log"
"syscall"
"time"
"net/url"
"net"
"github.com/lrstanley/girc"
"golang.org/x/net/proxy"
)
/////////////
/////////
/// RPC
var RPCPort string = "4321"
var RPCHost string = "127.0.0.1"
var namedPipe string = "sh0rtbus.cowrie.fifo"
/////////
/// IRC
var ircHost string = "br3ircdrchatmfsk.onion"
var ircPort int = 6667
var ircSSL bool = false
// Bot
var ircHome string = "#bees"
var ircOwner string = "kayos"
var ircNick string = "shortbus"
var ircUser string = "shortbus"
// Proxy
var proxyProto string = "socks5"
var proxyHost string = "127.0.0.1"
var proxyPort string = "9050"
// Cowrie
var cowVerbose bool = false
//////////
//////////////old arpc method
// server := arpc.NewServer()
// server.Handler.Handle("/psad", func(ctx *arpc.Context) {
// str := ""
// if err := ctx.Bind(&str); err == nil {
// ctx.Write(str)
// })
// server.Run(RPCHost+":"+RPCPort)
//
////////////////////////////////////////
func CowrieMsg(c *girc.Client) error {
syscall.Mkfifo(namedPipe, 0600)
for {
fmt.Println("[IPC] Opening named pipe for reading")
stdout, err := os.OpenFile(namedPipe, os.O_RDONLY, 0600)
var buff bytes.Buffer
if err != nil {
fmt.Println("[IPC] FATAL! Cannot open named pipe!")
return err
os.Exit(2)
}
io.Copy(&buff, stdout)
stdout.Close()
dataStr := buff.String()
if cowVerbose == true {
fmt.Printf("[IPC] sending data to [IRC]: %s\n", dataStr)
Phone(c,dataStr)
}
// psad <- dataStr
}
}
func Phone(c *girc.Client, Msg string,) {
c.Cmd.Message(ircHome, girc.Fmt(Msg))
}
func ircbot() {
//////////////////////////////////
//////////////////////////////////
///////////////// TCP Server
//inbound, err := net.ListenTCP("tcp", Host+":"+Port) // Define TCP Listener
//if err != nil { //logr.Fatal("RPC Listener error! " + err) }
//psad := new(psadRPC) // Create a new handler of type psadRPC
//rpc.Register(psad)// Adds all relevant functions to RPC registry (gives client options)
//rpc.Accept(inbound) // Begins listening on socket and offering functions
///////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////
//logr := //logr.WithContext("IRC")
if (len(os.Args) > 1) {
ircNick = os.Args[1]
}
client := girc.New(girc.Config{
Server: ircHost,
Port: ircPort,
Nick: ircNick,
Name: ircNick,
User: ircUser,
//Debug: os.Stdout,
SSL: ircSSL,
AllowFlood: true,
Out: os.Stdout,
Version: "sh0rtbus 0.1",
})
client.Handlers.Add(girc.CONNECTED, func(c *girc.Client, e girc.Event) {
fmt.Println("[IRC] Successfully connected to: " + ircHost + " on port " + string(ircPort))
c.Cmd.Join(ircHome)
fmt.Println("[IRC] Joining channel: " + ircHome)
err := CowrieMsg(c)
if err != nil {
fmt.Println("[IPC] Error: " + err.Error())
c.Cmd.Message(ircOwner, "IPC Error: err.Error()")
os.Exit(2)
}
})
client.Handlers.Add(girc.INVITE, func(c *girc.Client, e girc.Event) {
c.Cmd.Join(e.Last())
})
client.Handlers.Add(girc.ERR_CANNOTSENDTOCHAN, func(c *girc.Client, e girc.Event) {
Target := ircHome
if (strings.Contains(girc.Fmt(e.String()), ircHome)) {
Target = ircOwner
}
c.Cmd.Message(Target, "ERR_INVITEONLYCHAN:")
c.Cmd.Message(Target, girc.Fmt(e.String()))
c.Cmd.Message(Target, "------------------")
})
client.Handlers.Add(girc.ERR_INVITEONLYCHAN, func(c *girc.Client, e girc.Event) {
Phone(c,"ERR_INVITEONLYCHAN:")
Phone(c,girc.Fmt(e.String()))
Phone(c,"------------------")
})
client.Handlers.Add(girc.RPL_WHOISUSER, func(c *girc.Client, e girc.Event) {
Phone(c,"RPL_WHOISUSER:")
Phone(c,girc.Fmt(e.String()))
Phone(c,"------------------")
})
client.Handlers.Add(girc.RPL_WHOISOPERATOR, func(c *girc.Client, e girc.Event) {
Phone(c,"RPL_WHOISOPERATOR:")
Phone(c,girc.Fmt(e.String()))
Phone(c,"------------------")
})
client.Handlers.Add(girc.RPL_WHOISIDLE, func(c *girc.Client, e girc.Event) {
Phone(c,"RPL_WHOISIDLE:")
Phone(c,girc.Fmt(e.String()))
Phone(c,"------------------")
})
client.Handlers.Add(girc.RPL_WHOISSERVER, func(c *girc.Client, e girc.Event) {
Phone(c,"RPL_WHOISSERVER:")
Phone(c,girc.Fmt(e.String()))
Phone(c,"------------------")
})
client.Handlers.Add(girc.RPL_WHOISCHANOP, func(c *girc.Client, e girc.Event) {
Phone(c,"RPL_WHOISCHANOP:")
Phone(c,girc.Fmt(e.String()))
Phone(c,"------------------")
})
client.Handlers.Add(girc.RPL_TOPICWHOTIME, func(c *girc.Client, e girc.Event) {
Chan := strings.Split(e.String(), " ")[4]
if Chan != ircHome {
Phone(c,"Joined " + Chan + " on " + e.Source.ID())
}
})
client.Handlers.Add(girc.RPL_NAMREPLY, func(c *girc.Client, e girc.Event) {
Chan := strings.Split(e.String(), " ")[5]
if Chan != ircHome {
Phone(c,"Hosts on: " + Chan)
Phone(c,girc.Fmt(e.String()))
Phone(c,"------------------")
} else {
ircBanner(c)
}
})
client.Handlers.Add(girc.RPL_WHOISCHANNELS, func(c *girc.Client, e girc.Event) {
Phone(c,"RPL_WHOISCHANNELS:")
Phone(c,girc.Fmt(e.String()))
Phone(c,"------------------")
})
client.Handlers.Add(girc.PRIVMSG, func(c *girc.Client, e girc.Event) {
Sender := e.Source.Name
if (strings.HasPrefix(e.Last(), "!")) {
fmt.Println("[IRC] "+e.String())
thyWill := strings.Split(e.Last(), " ")
switch thyWill[0] {
case "!whois":
if len(thyWill) == 1 {
c.Cmd.ReplyTo(e, girc.Fmt("Usage: !whois nick"))
return
}
fmt.Println("[IRC] <"+string(Sender)+"> !spider " + thyWill[1])
if girc.IsValidNick(thyWill[1]) {
c.Cmd.Whois(thyWill[1])
return
} else {
fmt.Println("[IRC] ERROR: Bad whois target!")
Phone(c,"Bad Target! Wtf is that shit?")
return
}
case "!spider":
thyWill := strings.Split(e.Last(), " ")
var thyMark string
if len(thyWill) == 1 {
c.Cmd.ReplyTo(e, girc.Fmt("Usage: !spider #channel"))
return
}
thyMark = thyWill[1]
fmt.Println("[IRC] <"+string(Sender)+"> !spider " + thyMark)
if girc.IsValidChannel(thyMark) {
fmt.Println("[spider] Joining target " + thyMark)
Phone(c,"Joining " + thyMark)
c.Cmd.Join(thyMark)
return
} else {
fmt.Println("Bad scan target! " + thyMark)
Phone(c,"Bad Target! Wtf is that shit?")
return
}
case "!stop":
if Sender == ircOwner {
c.Close()
return
} else {
c.Cmd.Kick(ircHome,Sender,"yeah okay retard")
}
case "!motd":
ircBanner(c)
case "!cowrie":
if (len(thyWill) < 3) {
Phone(c,"((...)) Usage: ")
if cowVerbose == false {
Phone(c,"( {red}x x{c} ) ")
} else {
Phone(c,"( {green}$ ${c} ) ")
}
Phone(c," \\ / -v [0/1] verbose on/off ")
Phone(c," ^_^ ")
return
}
if thyWill[1] == "-v" {
if thyWill[2] == "0" {
cowVerbose = false
Phone(c, "Cowrie verbose log output stopped")
}
if thyWill[2] == "1" {
cowVerbose = true
Phone(c, "Cowrie verbose log output started")
}
}
default:
Phone(c,"what")
fmt.Println("Unknown command")
}
}
})
sslString := " "
////logr.Debug("Parsing proxy URI: " + ProxyURI)
//logr.Debug("Validating " + proxyProto + " proxy at host " + proxyHost + " on port " + proxyPort)
ProxyUrl, err := url.Parse(proxyProto + "://" + proxyHost + ":" + proxyPort)
if err != nil {
//logr.Fatal("Proxy URI is malformed!")
}
dialer, _ := proxy.FromURL(ProxyUrl, &net.Dialer{Timeout: 5 * time.Second})
for {
if ircSSL == true {
sslString = "-ssl"
}
fmt.Println("Connecting to " + ircHost + "/" + strconv.Itoa(ircPort) + " " + sslString)
fmt.Println("Dialing through a " + proxyProto + " proxy at host " + proxyHost + " on port " + proxyPort)
if err := client.DialerConnect(dialer); err != nil {
fmt.Println("ERROR! " + err.Error())
fmt.Println("reconnecting...")
//time.Sleep(1)
} else {
return
}
}
}
func b64d(str string) string {
data, err := base64.StdEncoding.DecodeString(str)
if err != nil {
return err.Error()
}
return string(data)
}
func conBanner() {
data := "ICAgICAgICAg4paI4paIICAgICAgIOKWiOKWiOKWiOKWiCAgICAgICAgICAg4paI4paIICAg4paI4paIICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAg4paR4paI4paIICAgICAg4paI4paR4paR4paR4paI4paIICAgICAgICAg4paR4paI4paIICDilpHilojiloggICAgICAgICAgICAgICAgICAgICAKICDilojilojilojilojilojilojilpHilojiloggICAgIOKWkeKWiCAg4paI4paR4paIIOKWiOKWiOKWiOKWiOKWiOKWiCDilojilojilojilojilojilojilpHilojiloggICAgICDilojiloggICDilojiloggIOKWiOKWiOKWiOKWiOKWiOKWiAog4paI4paI4paR4paR4paR4paRIOKWkeKWiOKWiOKWiOKWiOKWiOKWiCDilpHilogg4paIIOKWkeKWiOKWkeKWkeKWiOKWiOKWkeKWkeKWiOKWkeKWkeKWkeKWiOKWiOKWkSDilpHilojilojilojilojilojilogg4paR4paI4paIICDilpHilojilogg4paI4paI4paR4paR4paR4paRIArilpHilpHilojilojilojilojilogg4paR4paI4paI4paR4paR4paR4paI4paI4paR4paI4paIICDilpHilogg4paR4paI4paIIOKWkSAgIOKWkeKWiOKWiCAg4paR4paI4paI4paR4paR4paR4paI4paI4paR4paI4paIICDilpHilojilojilpHilpHilojilojilojilojiloggCiDilpHilpHilpHilpHilpHilojilojilpHilojiloggIOKWkeKWiOKWiOKWkeKWiCAgIOKWkeKWiCDilpHilojiloggICAgIOKWkeKWiOKWiCAg4paR4paI4paIICDilpHilojilojilpHilojiloggIOKWkeKWiOKWiCDilpHilpHilpHilpHilpHilojilogKIOKWiOKWiOKWiOKWiOKWiOKWiCDilpHilojiloggIOKWkeKWiOKWiOKWkSDilojilojilojilogg4paR4paI4paI4paIICAgICDilpHilpHilojilogg4paR4paI4paI4paI4paI4paI4paIIOKWkeKWkeKWiOKWiOKWiOKWiOKWiOKWiCDilojilojilojilojilojiloggCuKWkeKWkeKWkeKWkeKWkeKWkSAg4paR4paRICAg4paR4paRICDilpHilpHilpHilpEgIOKWkeKWkeKWkSAgICAgICDilpHilpEgIOKWkeKWkeKWkeKWkeKWkSAgICDilpHilpHilpHilpHilpHilpEg4paR4paR4paR4paR4paR4paRICAK"
fmt.Println(b64d(data))
return
}
func ircBanner(c *girc.Client) {
c.Cmd.Message(ircHome, girc.Fmt("{purple,black} {green,black} ___ {purple,black} {c}"))
c.Cmd.Message(ircHome, girc.Fmt("{purple,black} | {green,black}| /|{purple,black} | | {silver,black}v0.1{c}{red,black}a {c}"))
c.Cmd.Message(ircHome, girc.Fmt("{purple,black} - |- {green,black}| + |{purple,black} |- -+- |- - {c}"))
c.Cmd.Message(ircHome, girc.Fmt("{purple,black} \\ | | {green,black}|/ |{purple,black} | | | | | | \\ {c}"))
c.Cmd.Message(ircHome, girc.Fmt("{purple,black} - {green,black} --- {purple,black} - - -- - {c}"))
return
}
func main() {
if (len(os.Args) > 2 && os.Args[1] == "client") {
//fmt.Println("Starting client...")
} else {
conBanner()
ircbot()
}
}