Merge pull request #21 from signalsciences/add_server_flavor_support

Add support for 'server_flavor' revproxy config option

Author: vcarvajal-sigsci

CHANGELOG.md

@@ -1,5 +1,9 @@
 # GoLang Module Release Notes
 
+## 1.9.0 2020-10-22
+
+* Added `server_flavor` config option.
+
 ## 1.8.2 2020-06-15
 
 * Updated revision for github actions release.

VERSION

@@ -1 +1 @@
-1.8.2
+1.9.0

config.go

@@ -33,6 +33,8 @@ var (
 	DefaultTimeout = 100 * time.Millisecond
 	// DefaultServerIdentifier is the default value
 	DefaultServerIdentifier = runtime.Version()
+	// DefaultServerFlavor is the default value
+	DefaultServerFlavor = ""
 )
 
 // HeaderExtractorFunc is a header extraction function
@@ -53,6 +55,7 @@ type ModuleConfig struct {
 	rpcAddress                string
 	rpcNetwork                string
 	serverIdentifier          string
+	serverFlavor              string
 	timeout                   time.Duration
 }
 
@@ -72,6 +75,7 @@ func NewModuleConfig(options ...ModuleConfigOption) (*ModuleConfig, error) {
 		rpcAddress:                DefaultRPCAddress,
 		rpcNetwork:                DefaultRPCNetwork,
 		serverIdentifier:          DefaultServerIdentifier,
+		serverFlavor:              DefaultServerFlavor,
 		timeout:                   DefaultTimeout,
 	}
 	if err := c.SetOptions(options...); err != nil {
@@ -185,6 +189,11 @@ func (c *ModuleConfig) ServerIdentifier() string {
 	return c.serverIdentifier
 }
 
+// ServerFlavor returns the configuration value
+func (c *ModuleConfig) ServerFlavor() string {
+	return c.serverFlavor
+}
+
 // Timeout returns the configuration value
 func (c *ModuleConfig) Timeout() time.Duration {
 	return c.timeout
@@ -335,6 +344,15 @@ func ServerIdentifier(id string) ModuleConfigOption {
 	}
 }
 
+// ServerFlavor is a function argument that sets the server
+// flavor for custom setups using revproxy.
+func ServerFlavor(serverFlavor string) ModuleConfigOption {
+	return func(c *ModuleConfig) error {
+		c.serverFlavor = serverFlavor
+		return nil
+	}
+}
+
 // FromModuleConfig allow cloning the config
 func FromModuleConfig(mcfg *ModuleConfig) ModuleConfigOption {
 	return func(c *ModuleConfig) error {

module.go

@@ -63,7 +63,7 @@ func NewModule(h http.Handler, options ...ModuleConfigOption) (*Module, error) {
 	in := RPCMsgIn{
 		ModuleVersion: m.config.ModuleIdentifier(),
 		ServerVersion: m.config.ServerIdentifier(),
-		ServerFlavor:  "",
+		ServerFlavor:  m.config.ServerFlavor(),
 		Timestamp:     now.Unix(),
 		NowMillis:     now.UnixNano() / 1e6,
 	}
@@ -225,7 +225,7 @@ func (m *Module) inspectorPreRequest(req *http.Request) (inspin2 RPCMsgIn2, out
 		req.Body = ioutil.NopCloser(bytes.NewBuffer(reqbody))
 	}
 
-	inspin := NewRPCMsgIn(req, reqbody, -1, -1, -1, m.config.ModuleIdentifier(), m.config.ServerIdentifier())
+	inspin := NewRPCMsgInWithModuleConfig(m.config, req, reqbody)
 	m.extractHeaders(req, inspin)
 
 	if m.config.Debug() {
@@ -371,6 +371,53 @@ func NewRPCMsgIn(r *http.Request, postbody []byte, code int, size int64, dur tim
 	}
 }
 
+// NewRPCMsgInWithModuleConfig creates a message from a ModuleConfig object
+// End-users of the golang module never need to use this
+// directly and it is only exposed for performance testing
+func NewRPCMsgInWithModuleConfig(mcfg *ModuleConfig, r *http.Request, postbody []byte) *RPCMsgIn {
+
+	now := time.Now()
+
+	// assemble a message to send to inspector
+	tlsProtocol := ""
+	tlsCipher := ""
+	scheme := "http"
+	if r.TLS != nil {
+		// convert golang/spec integers into something human readable
+		scheme = "https"
+		tlsProtocol = tlstext.Version(r.TLS.Version)
+		tlsCipher = tlstext.CipherSuite(r.TLS.CipherSuite)
+	}
+
+	// golang removes Host header from req.Header map and
+	// promotes it to r.Host field. Add it back as the first header.
+	hin := convertHeaders(r.Header)
+	if len(r.Host) > 0 {
+		hin = append([][2]string{{"Host", r.Host}}, hin...)
+	}
+
+	return &RPCMsgIn{
+		ModuleVersion:  mcfg.ModuleIdentifier(),
+		ServerVersion:  mcfg.ServerIdentifier(),
+		ServerFlavor:   mcfg.ServerFlavor(),
+		ServerName:     r.Host,
+		Timestamp:      now.Unix(),
+		NowMillis:      now.UnixNano() / 1e6,
+		RemoteAddr:     stripPort(r.RemoteAddr),
+		Method:         r.Method,
+		Scheme:         scheme,
+		URI:            r.RequestURI,
+		Protocol:       r.Proto,
+		TLSProtocol:    tlsProtocol,
+		TLSCipher:      tlsCipher,
+		ResponseCode:   -1,
+		ResponseMillis: 0,
+		ResponseSize:   -1,
+		PostBody:       string(postbody),
+		HeadersIn:      hin,
+	}
+}
+
 // stripPort removes any port from an address (e.g., the client port from the RemoteAddr)
 func stripPort(ipdots string) string {
 	host, _, err := net.SplitHostPort(ipdots)

module_test.go

@@ -15,6 +15,75 @@ import (
 	"time"
 )
 
+func TestNewRPCMsgInWithModuleConfigFromRequest(t *testing.T) {
+
+	c, err := NewModuleConfig(
+		AllowUnknownContentLength(true),
+		ServerFlavor("SugarAndSpice"),
+		AltResponseCodes(403),
+		AnomalyDuration(10*time.Second),
+		AnomalySize(8192),
+		CustomInspector(&RPCInspector{}, func(_ *http.Request) bool { return true }, func(_ *http.Request) {}),
+		CustomHeaderExtractor(func(_ *http.Request) (http.Header, error) { return nil, nil }),
+		Debug(true),
+		MaxContentLength(500000),
+		Socket("tcp", "0.0.0.0:1234"),
+		Timeout(10*time.Millisecond),
+	)
+	if err != nil {
+		t.Fatalf("Failed to create module config: %s", err)
+	}
+
+	b := bytes.Buffer{}
+	b.WriteString("test")
+	r, err := http.NewRequest("GET", "http://localhost/", &b)
+	if err != nil {
+		t.Fatal(err)
+	}
+	r.RemoteAddr = "127.0.0.1"
+	r.Header.Add("If-None-Match", `W/"wyzzy"`)
+	r.RequestURI = "http://localhost/"
+	r.TLS = &tls.ConnectionState{}
+
+	want := RPCMsgIn{
+		ServerName:   "localhost",
+		ServerFlavor: "SugarAndSpice",
+		Method:       "GET",
+		Scheme:       "https",
+		URI:          "http://localhost/",
+		Protocol:     "HTTP/1.1",
+		RemoteAddr:   "127.0.0.1",
+		HeadersIn:    [][2]string{{"Host", "localhost"}, {"If-None-Match", `W/"wyzzy"`}},
+	}
+	eq := func(got, want RPCMsgIn) (ne string, equal bool) {
+		switch {
+		case got.ServerName != want.ServerName:
+			return "ServerHostname", false
+		case got.Method != want.Method:
+			return "Method", false
+		case got.Scheme != want.Scheme:
+			return "Scheme", false
+		case got.URI != want.URI:
+			return "URI", false
+		case got.Protocol != want.Protocol:
+			return "Protocol", false
+		case got.RemoteAddr != want.RemoteAddr:
+			return "RemoteAddr", false
+		case !reflect.DeepEqual(got.HeadersIn, want.HeadersIn):
+			return "HeadersIn", false
+		case got.ServerFlavor != want.ServerFlavor:
+			return "ServerFlavor", false
+		default:
+			return "", true
+		}
+	}
+
+	got := NewRPCMsgInWithModuleConfig(c, r, nil)
+	if ne, equal := eq(*got, want); !equal {
+		t.Errorf("NewRPCMsgInWithModuleConfig: incorrect %q", ne)
+	}
+}
+
 func TestNewRPCMsgFromRequest(t *testing.T) {
 	b := bytes.Buffer{}
 	b.WriteString("test")

version.go

@@ -1,3 +1,3 @@
 package sigsci
 
-const version = "1.8.0"
+const version = "1.9.0"