* Cleaned code

Author: LSD00

main.go

@@ -9,28 +9,26 @@ import (
 )
 
 var (
-	domain, reqfile, wordlist, invalid, flags string
-	th                                        int
-	opt                                       workers.Options
+	invalid, encoders string
+	options           workers.Options
 )
 
 func main() {
-	kingpin.Flag("domain", "target domain").Required().Short('d').StringVar(&domain)
-	kingpin.Flag("request", "file with http request").Required().Short('r').StringVar(&reqfile)
-	kingpin.Flag("wordlist", "file with wordlist").Required().Short('w').StringVar(&wordlist)
-	kingpin.Flag("regex", "regex for search").Default(".+").StringVar(&opt.Regex)
-	kingpin.Flag("threads", "setting threads").Default("25").IntVar(&th)
-	kingpin.Flag("tls", "is target use tls").Default("false").BoolVar(&opt.TlsEnabled)
+	kingpin.Flag("domain", "target domain").Required().Short('d').StringVar(&options.Domain)
+	kingpin.Flag("request", "file with http request").Required().Short('r').StringVar(&options.RequestFile)
+	kingpin.Flag("wordlist", "file with wordlist").Required().Short('w').StringVar(&options.WordlistFile)
+	kingpin.Flag("regex", "regex for search").Default(".+").StringVar(&options.Regex)
+	kingpin.Flag("threads", "setting threads").Default("25").IntVar(&options.Concurrents)
+	kingpin.Flag("tls", "is target use tls").Default("false").BoolVar(&options.TlsEnabled)
 	kingpin.Flag("bad-codes", "invalid codes for fuzzing ex. 404, 503, 400").Default("404").StringVar(&invalid)
-	kingpin.Flag("encoders", "encode payloads: urlencode, base64, hex").Default("none").Short('e').StringVar(&flags)
+	kingpin.Flag("encoders", "encode payloads: urlencode, base64, hex").Default("none").Short('e').StringVar(&encoders)
 	kingpin.Parse()
-	opt.InvalidCode = strings.Split(strings.ReplaceAll(invalid, " ", ""), ",")
-	worker, err := workers.NewPool(wordlist, reqfile, th)
+	options.InvalidCode = strings.Split(strings.ReplaceAll(invalid, " ", ""), ",")
+	options.Encoders = strings.Split(strings.ReplaceAll(encoders, " ", ""), ",")
+	worker, err := workers.NewPool(options)
 	if err != nil {
 		fmt.Println(err)
 	}
-	worker.AddFlags(strings.Split(strings.ReplaceAll(flags, " ", ""), ","))
-	worker.Options = opt
 	fmt.Println(`
 	 _    _      _     ______             
 	| |  | |    | |   |  ___|            
@@ -41,5 +39,5 @@ func main() {
 										 
 										 
 										 `)
-	worker.Fuzz(domain)
+	worker.Fuzz()
 }

pkg/formatter/formatter.go

@@ -14,11 +14,12 @@ type Payload struct {
 	encoders                            map[string]EncoderFunc
 	encoderFlags                        []string
 	Payload                             string
-	defaultContentLength, ContentLength int
+	DefaultContentLength, ContentLength int
 }
 
 func NewPayload(payload string, flags []string) *Payload {
 	encoders := map[string]EncoderFunc{
+		// "none" is needed in case the encoder is not passed, because then we get an error
 		"none": func(data *string) {
 			return
 		},
@@ -35,12 +36,13 @@ func NewPayload(payload string, flags []string) *Payload {
 	return &Payload{Payload: payload, encoders: encoders, encoderFlags: flags}
 }
 
-func CountDefaultContentLenght(requestfile string) int {
+// This function is needed because fasthttp does not calculate the Content-length header.
+func CountDefaultContentLength(requestfile string) int {
 	request, _ := os.ReadFile(requestfile)
 	var content string
 	splited_request := strings.Split(strings.ReplaceAll(string(request), "\r\n", "\n"), "\n")
 	for i := 0; i < len(splited_request); i++ {
-		if len(splited_request[i]) == 0 {
+		if len(splited_request[i]) == 0 { // 0 - no data, just empty string
 			dataslice := splited_request[i:]
 			content = strings.Join(strings.Fields(strings.Join(dataslice[:], "")), "")
 			break
@@ -49,13 +51,9 @@ func CountDefaultContentLenght(requestfile string) int {
 	return len(content) - len("{{.Payload}}")
 }
 
-func (p *Payload) AddDefaultContentLenght(lenght int) {
-	p.defaultContentLength = lenght
-}
-
 func (p *Payload) CreatePayload() {
 	for _, value := range p.encoderFlags {
 		p.encoders[value](&p.Payload)
 	}
-	p.ContentLength = p.defaultContentLength + len(p.Payload)
+	p.ContentLength = p.DefaultContentLength + len(p.Payload)
 }

pkg/workers/workers.go

@@ -15,23 +15,23 @@ import (
 )
 
 type Options struct {
-	TlsEnabled  bool
-	Regex       string
-	InvalidCode []string
+	Concurrents                              int
+	TlsEnabled                               bool
+	Regex, Domain, RequestFile, WordlistFile string
+	InvalidCode, Encoders                    []string
 }
 
 type Pool struct {
-	concurrents      int
-	wordlists, flags []string
-	deflenght        int
-	req              *template.Template
-	Options          Options
+	wordlists      []string
+	default_length int
+	req            *template.Template
+	options        Options
 }
 
-func NewPool(wordlist, reqfile string, concurrents int) (*Pool, error) {
+func NewPool(options Options) (*Pool, error) {
 	var pool Pool
-	pool.concurrents = concurrents
-	file, err := os.Open(wordlist)
+	pool.options = options
+	file, err := os.Open(options.WordlistFile)
 	if err != nil {
 		return nil, err
 	}
@@ -40,34 +40,33 @@ func NewPool(wordlist, reqfile string, concurrents int) (*Pool, error) {
 	for reader.Scan() {
 		pool.wordlists = append(pool.wordlists, reader.Text())
 	}
-	pool.req, err = template.ParseFiles(reqfile)
-	pool.deflenght = formatter.CountDefaultContentLenght(reqfile)
+	pool.req, err = template.ParseFiles(options.RequestFile)
+	pool.default_length = formatter.CountDefaultContentLength(options.RequestFile)
 	if err != nil {
 		return nil, err
 	}
 	return &pool, nil
 }
 
-func (p *Pool) AddFlags(flags []string) {
-	p.flags = flags
-}
-
-func (p *Pool) worker(wg *sync.WaitGroup, wordlist []string, domain string) {
+func (p *Pool) worker(wg *sync.WaitGroup, chunked_wordlist []string) {
 	defer wg.Done()
-	re := regexp.MustCompile(p.Options.Regex)
-	for _, value := range wordlist {
+	re := regexp.MustCompile(p.options.Regex)
+	for _, value := range chunked_wordlist {
 		var buf bytes.Buffer
-		payload := formatter.NewPayload(value, p.flags)
-		payload.AddDefaultContentLenght(p.deflenght)
+		payload := formatter.NewPayload(value, p.options.Encoders)
+		payload.DefaultContentLength = p.default_length
 		payload.CreatePayload()
 		p.req.Execute(&buf, payload)
-		worker := reqgen.NewWorker(p.Options.TlsEnabled, bufio.NewReader(&buf), domain)
+		worker := reqgen.NewWorker(p.options.TlsEnabled, bufio.NewReader(&buf), p.options.Domain)
 		resp, err := worker.MakeRequest()
+
+		// Io.WriteString is necessary because it immediately writes to stdout
+		// with fmt.Println there are problems and it may not output all
 		io.WriteString(os.Stdout, buf.String())
 		if err != nil {
 			io.WriteString(os.Stdout, err.Error())
 			return
-		} else if !slices.Contains(p.Options.InvalidCode, fmt.Sprint(resp.Status)) && re.MatchString(resp.BodyData) {
+		} else if !slices.Contains(p.options.InvalidCode, fmt.Sprint(resp.Status)) && re.MatchString(resp.BodyData) {
 			var formatted_code string
 			if resp.Status >= 200 && resp.Status < 300 {
 				formatted_code = fmt.Sprintf("\033[92m%d\033[0m", resp.Status)
@@ -81,18 +80,18 @@ func (p *Pool) worker(wg *sync.WaitGroup, wordlist []string, domain string) {
 	}
 }
 
-func (p *Pool) Fuzz(domain string) {
+func (p *Pool) Fuzz() {
 	var wg sync.WaitGroup
-	chunks := len(p.wordlists) / p.concurrents
-	for i := 0; i < p.concurrents; i++ {
+	chunks := len(p.wordlists) / p.options.Concurrents
+	for i := 0; i < p.options.Concurrents; i++ {
 		var chunked_wordlist []string
-		if i != p.concurrents-1 {
+		if i != p.options.Concurrents-1 {
 			chunked_wordlist = p.wordlists[i*chunks : (i+1)*chunks]
 		} else {
 			chunked_wordlist = p.wordlists[i*chunks:]
 		}
 		wg.Add(1)
-		go p.worker(&wg, chunked_wordlist, domain)
+		go p.worker(&wg, chunked_wordlist)
 	}
 	wg.Wait()
 }