go-guerrilla/fuzz.go

// build gofuzz

package guerrilla

import (
	"bytes"
	"fmt"
	"github.com/flashmob/go-guerrilla/backends"
	"github.com/flashmob/go-guerrilla/log"
	"github.com/flashmob/go-guerrilla/mail"
	"github.com/flashmob/go-guerrilla/mocks"
	"io"
	"sync"
	"time"
)

var logOff log.Logger
var fuzzServer *server
var envelopePool *mail.Pool

func init() {
	sc := getFuzzServerConfig()
	logOff, _ = log.GetLogger(sc.LogFile, log.ErrorLevel.String())
	fuzzServer = getFuzzServer(sc)
	isFuzzDebug = false

	envelopePool = mail.NewPool(sc.MaxClients)

}

func getFuzzServerConfig() *ServerConfig {
	sc := &ServerConfig{
		IsEnabled:       true, //
		Hostname:        "fuzzme.test.com",
		MaxSize:         1024, // smtp message max size
		PrivateKeyFile:  "./tests/mail.guerrillamail.com.key.pem",
		PublicKeyFile:   "./tests/mail.guerrillamail.com.cert.pem",
		Timeout:         5,
		ListenInterface: "127.0.0.1:2529",
		StartTLSOn:      true,
		TLSAlwaysOn:     false,
		MaxClients:      3000,
		LogFile:         "off",
	}
	return sc
}

// getMockServer gets a new server using sc. Server will be using a using the dummy backend
// RCP TO command only allows test.com host
func getFuzzServer(sc *ServerConfig) *server {
	var logOpenError error
	var mainlog log.Logger
	mainlog, logOpenError = log.GetLogger(sc.LogFile, log.ErrorLevel.String())
	if logOpenError != nil {
		mainlog.WithError(logOpenError).Errorf("Failed creating a logger for mock conn [%s]", sc.ListenInterface)
	}
	backend, err := backends.New(backends.BackendConfig{
		"log_received_mails": true, "save_process_": "HeadersParser|Header|Debugger"}, mainlog)
	if err != nil {
		//t.Error("new dummy backend failed because:", err)
	}
	server, err := newServer(sc, backend, mainlog)
	if err != nil {
		//t.Error("new server failed because:", err)
	} else {
		server.setAllowedHosts([]string{"test.com"})
	}

	return server
}

var mockClient *client
var isFuzzDebug bool

// Fuzz passes the data to the mock connection
// Data is random input generated by go-fuzz, note that in most cases it is invalid.
// The function must return 1 if the fuzzer should increase priority of the given input during subsequent
// fuzzing (for example, the input is lexically correct and was parsed successfully); -1 if the input must
// not be added to corpus even if gives new coverage; and 0 otherwise
func Fuzz(data []byte) int {

	var wg sync.WaitGroup
	// grab a new mocked tcp connection, it consists of two pipes (io.Pipe)
	conn := mocks.NewConn()

	// Get a client from the pool
	poolable, err := fuzzServer.clientPool.Borrow(conn.Server, 1, logOff, envelopePool)
	if c, ok := poolable.(*client); !ok {
		panic("cannot borrow from pool")
	} else {
		mockClient = c
	}

	defer func() {
		conn.Close()
		// wait for handleClient to exit
		wg.Wait()
		// return to the pool
		fuzzServer.clientPool.Return(mockClient)
	}()

	wg.Add(1)
	go func() {
		fuzzServer.handleClient(mockClient)
		wg.Done()
	}()
	b := make([]byte, 1024)
	if n, err := conn.Client.Read(b); err != nil {
		return 0
	} else if isFuzzDebug {
		fmt.Println("Read", n, string(b))
	}

	// Feed the connection with fuzz data (we are the _client_ end of the connection)
	if _, err = io.Copy(conn.Client, bytes.NewReader(data)); err != nil {
		return 0
	}

	// allow handleClient to process
	time.Sleep(time.Millisecond + 10)

	if mockClient.bufout.Buffered() == 0 {
		// nothing to read - no complete commands sent?
		return 0
	}
	if n, err := conn.Client.Read(b); err != nil {
		return 0
	} else if isFuzzDebug {
		fmt.Println("Read", n, string(b))
	}

	return 1
}