linting

Author: lobsterjerusalem

protocol/dotnetremoting/dotnetremoting.go

@@ -1,6 +1,6 @@
 // This is effectively a library for .NET remoting functionality
 // The exploit remoting service tool by tyranid was the primary
-// resource for this and this is basically a port of that project with the ntlmssp 
+// resource for this and this is basically a port of that project with the ntlmssp
 // Note: Everything is in little endian
 
 // Usage Example:
@@ -29,43 +29,45 @@
 package dotnetremoting
 
 import (
+	"encoding/binary"
 	"fmt"
 	"net"
 	"net/url"
 	"time"
-	"encoding/binary"
 
 	"github.com/LeakIX/nns"
 	"github.com/LeakIX/ntlmssp"
-	"github.com/vulncheck-oss/go-exploit/transform"
 	"github.com/vulncheck-oss/go-exploit/output"
+	"github.com/vulncheck-oss/go-exploit/transform"
 )
 
 // types and 'enums'.
-type Message struct{
+type Message struct {
 	PreambleData string
-	HeaderData string
+	HeaderData   string
 }
 
-// Strings, because go thinks strings are as nifty as bytes
+// Strings, because go thinks strings are as nifty as bytes.
 type MessageResponse struct {
-	MajorVersion string
-	MinorVersion string
-	OperationType string
+	MajorVersion        string
+	MinorVersion        string
+	OperationType       string
 	ContentDistribution string
-	DataLength int
-	Headers map[string]string
-	Data string
+	DataLength          int
+	Headers             map[string]string
+	Data                string
 }
 
 type OperationType string
+
 const ( // OPERATION TYPES (ushort)
 	OperationTypeRequest       OperationType = "\x00\x00"
 	OperationTypeOneWayRequest OperationType = "\x01\x00"
 	OperationTypeReply         OperationType = "\x02\x00"
 )
 
 type HeaderToken string
+
 const ( // HEADER TOKENS (ushort)
 	HeaderTokenEndHeaders      HeaderToken = "\x00\x00"
 	HeaderTokenCustom          HeaderToken = "\x01\x00"
@@ -77,6 +79,7 @@ const ( // HEADER TOKENS (ushort)
 )
 
 type HeaderDataFormat string
+
 const ( // HEADER DATA FORMAT (byte)
 	HeaderDataFormatVoid          HeaderDataFormat = "\x00"
 	HeaderDataFormatCountedString HeaderDataFormat = "\x01"
@@ -86,36 +89,39 @@ const ( // HEADER DATA FORMAT (byte)
 )
 
 type ContentDistribution string
+
 const ( // CONTENT DISTRIBUTION (ushort)
 	ContentDistributionNotChunked ContentDistribution = "\x00\x00"
 	ContentDistributionChunked    ContentDistribution = "\x01\x00"
 )
 
 type StringEncoding string
+
 const ( // STRING ENCODING (byte)
 	StringEncodingUnicode StringEncoding = "\x00"
 	StringEncodingUtf8    StringEncoding = "\x01"
 )
 
 type TCPStatusCode string
+
 const ( // TCP STATUS CODE (byte)
 	TCPStatusCodeSuccess TCPStatusCode = "\x00"
 	TCPStatusCodeError   TCPStatusCode = "\x01"
 )
 
-
 // The 'preamble' is basically the set of headers before the body.
 func (msg *Message) WritePreamble(uri string, opType OperationType, dataLength int, contentDistribution ContentDistribution, contentType string) {
 	uriObj, err := url.Parse(uri)
 	if err != nil {
 		output.PrintfFrameworkError("Could not write preamble: error trying to parse provided uri=%s, err=%s", uri, err)
-		return 
+
+		return
 	}
 	msg.PreambleData = ".NET"
-	msg.PreambleData += "\x01" // major version
-	msg.PreambleData += "\x00" // minor version
-	msg.PreambleData += string(opType) // operation type
-	msg.PreambleData += string(contentDistribution) // content distribution
+	msg.PreambleData += "\x01"                                // major version
+	msg.PreambleData += "\x00"                                // minor version
+	msg.PreambleData += string(opType)                        // operation type
+	msg.PreambleData += string(contentDistribution)           // content distribution
 	msg.PreambleData += transform.PackLittleInt32(dataLength) // length of payload to be sent
 	msg.AddContentTypeHeader(contentType)
 	if uri != "" {
@@ -153,7 +159,7 @@ func (msg *Message) AddURIHeader(uri string, headerToken HeaderToken) {
 // this will probably be application/octet-stream almost every time but making options.
 func (msg *Message) AddContentTypeHeader(contentType string) {
 	msg.HeaderData += string(HeaderTokenContentType)
-	msg.HeaderData +=  string(HeaderDataFormatCountedString)
+	msg.HeaderData += string(HeaderDataFormatCountedString)
 	addCountedString(&msg.HeaderData, StringEncodingUtf8, contentType)
 }
 
@@ -173,7 +179,7 @@ func (msg *Message) AddStatusCodeHeader(isError bool) { // untested
 		msg.HeaderData += transform.PackLittleInt16(1)
 
 		return
-	} 
+	}
 	// success
 	msg.HeaderData += transform.PackLittleInt16(0)
 }
@@ -197,12 +203,12 @@ func (msg *MessageResponse) Dump() {
 // Parsing functions.
 func ParseResponseFromConn(conn net.Conn) (MessageResponse, bool) {
 	msg := MessageResponse{}
-	magicBuf               := make ([]byte, 4)
-	majorVerBuf            := make ([]byte, 1)
-	minorVerBuf            := make ([]byte, 1)
-	opTypeBuf              := make ([]byte, 2)
-	contentDistributionBuf := make ([]byte, 2)
-	dataLengthBuf          := make ([]byte, 4)
+	magicBuf := make([]byte, 4)
+	majorVerBuf := make([]byte, 1)
+	minorVerBuf := make([]byte, 1)
+	opTypeBuf := make([]byte, 2)
+	contentDistributionBuf := make([]byte, 2)
+	dataLengthBuf := make([]byte, 4)
 
 	// checking magic bytes from message
 	_, err := conn.Read(magicBuf)
@@ -241,7 +247,7 @@ func ParseResponseFromConn(conn net.Conn) (MessageResponse, bool) {
 
 		return MessageResponse{}, false
 	}
-	msg.OperationType  = string(opTypeBuf)
+	msg.OperationType = string(opTypeBuf)
 
 	_, err = conn.Read(contentDistributionBuf)
 	if err != nil {
@@ -294,14 +300,14 @@ func readHeadersFromConn(conn net.Conn) (map[string]string, bool) {
 	}
 
 	// while we have not read the End of Headers 'token'
-	for string(tokenBuf) != string(HeaderTokenEndHeaders) { 
+	for string(tokenBuf) != string(HeaderTokenEndHeaders) {
 		name := string(tokenBuf)
 		value := ""
 
 		switch string(tokenBuf) {
 		case string(HeaderTokenCustom): // HeaderTokenCustom
 			// untested
-			str, ok  := readHeaderStringFromConn(conn)
+			str, ok := readHeaderStringFromConn(conn)
 			if !ok {
 				output.PrintFrameworkError("Failed reading custom header name from response")
 
@@ -326,43 +332,43 @@ func readHeadersFromConn(conn net.Conn) (map[string]string, bool) {
 			}
 
 			switch string(dataTypeBuf) {
-				case string(HeaderDataFormatVoid):
-					break
-				case string(HeaderDataFormatCountedString):
-					data, ok := readHeaderStringFromConn(conn)
-					if !ok {
-						output.PrintFrameworkError("Failed reading counted header string")
-
-						return map[string]string{}, false
-					}
-					value = data
-				case string(HeaderDataFormatByte):
-					dataBuf := make([]byte, 1)
-					_, err = conn.Read(dataBuf)
-					if err != nil {
-						output.PrintfFrameworkError("Failed reading format byte, err=%s", err)
-
-						return map[string]string{}, false
-					}
-					value = string(dataBuf)
-				case string(HeaderDataFormatUint16):
-					dataBuf := make([]byte, 2)
-					_, err = conn.Read(dataBuf)
-					if err != nil {
-						output.PrintfFrameworkError("Failed reading uint16, err=%s", err)
-
-						return map[string]string{}, false
-					}
-					value = string(dataBuf)
-				case string(HeaderDataFormatInt32):
-					dataBuf := make([]byte, 4)
-					_, err = conn.Read(dataBuf)
-					if err != nil {
-						output.PrintfFrameworkError("Failed reading uint32, err=%s", err)
-
-						return map[string]string{}, false
-					}
-					value = string(dataBuf)
+			case string(HeaderDataFormatVoid):
+				break
+			case string(HeaderDataFormatCountedString):
+				data, ok := readHeaderStringFromConn(conn)
+				if !ok {
+					output.PrintFrameworkError("Failed reading counted header string")
+
+					return map[string]string{}, false
+				}
+				value = data
+			case string(HeaderDataFormatByte):
+				dataBuf := make([]byte, 1)
+				_, err = conn.Read(dataBuf)
+				if err != nil {
+					output.PrintfFrameworkError("Failed reading format byte, err=%s", err)
+
+					return map[string]string{}, false
+				}
+				value = string(dataBuf)
+			case string(HeaderDataFormatUint16):
+				dataBuf := make([]byte, 2)
+				_, err = conn.Read(dataBuf)
+				if err != nil {
+					output.PrintfFrameworkError("Failed reading uint16, err=%s", err)
+
+					return map[string]string{}, false
+				}
+				value = string(dataBuf)
+			case string(HeaderDataFormatInt32):
+				dataBuf := make([]byte, 4)
+				_, err = conn.Read(dataBuf)
+				if err != nil {
+					output.PrintfFrameworkError("Failed reading uint32, err=%s", err)
+
+					return map[string]string{}, false
+				}
+				value = string(dataBuf)
 			}
 		}
 
@@ -375,7 +381,7 @@ func readHeadersFromConn(conn net.Conn) (map[string]string, bool) {
 
 			return map[string]string{}, false
 		}
-		output.PrintfFrameworkTrace("token value %x",tokenBuf)
+		output.PrintfFrameworkTrace("token value %x", tokenBuf)
 	}
 	output.PrintFrameworkTrace("done parsing headers")
 
@@ -384,7 +390,7 @@ func readHeadersFromConn(conn net.Conn) (map[string]string, bool) {
 
 func readHeaderStringFromConn(conn net.Conn) (string, bool) {
 	encodingTypeBuf := make([]byte, 1)
-	stringLengthBuf    := make([]byte, 4)
+	stringLengthBuf := make([]byte, 4)
 	_, err := conn.Read(encodingTypeBuf)
 	if err != nil {
 		output.PrintfFrameworkError("Failed reading encoding type from header string")
@@ -401,7 +407,6 @@ func readHeaderStringFromConn(conn net.Conn) (string, bool) {
 	// encodingType := string(encodingTypeBuf) // sorry, just going to ignore this for now.
 	stringLength := int(binary.LittleEndian.Uint32(stringLengthBuf))
 
-
 	stringData, ok := readNBytes(conn, stringLength)
 	if !ok {
 		return "", false
@@ -410,8 +415,8 @@ func readHeaderStringFromConn(conn net.Conn) (string, bool) {
 	return stringData, true
 }
 
-// don't love this function
-func readNBytes(conn net.Conn, n int) (string, bool){
+// don't love this function.
+func readNBytes(conn net.Conn, n int) (string, bool) {
 	data := ""
 	buf := make([]byte, 1) // ugh...
 	remaining := n
@@ -432,8 +437,9 @@ func readNBytes(conn net.Conn, n int) (string, bool){
 }
 
 // Helper functions.
-//nolint:unparam
 // This is private on purpose to promote helper functions to keep things easier to use.
+//
+//nolint:unparam
 func addCountedString(msg *string, encodingType StringEncoding, stringValue string) {
 	*msg += string(encodingType)
 	*msg += transform.PackLittleInt32(len(stringValue))
@@ -443,15 +449,15 @@ func addCountedString(msg *string, encodingType StringEncoding, stringValue stri
 // Some connection helper functions, exists mostly to wrap around ntlmssp.
 // For anonymous connections, just pass "" to user and password.
 func GetNTLMSSPTCPConnection(user string, password string, socketAddr string) (net.Conn, error) {
-	 ntlmsspClient, err := ntlmssp.NewClient(ntlmssp.SetCompatibilityLevel(1), ntlmssp.SetUserInfo(user, password))
-	 if err != nil {
-		 return nil, fmt.Errorf("error creating NTLMSSPClient, err=%w", err)
-	 }
-	 nnsConn, err := nns.DialNTLMSSP(socketAddr, ntlmsspClient, 10 * time.Second)
-	 if err != nil {
-		 return nil, fmt.Errorf("error connecting with NTLMSSP to %s, err=%w", socketAddr, err)
-	 }
-	 output.PrintfFrameworkStatus("NTLMSSP connection to %s was successful", socketAddr)
-
-	 return nnsConn, nil
+	ntlmsspClient, err := ntlmssp.NewClient(ntlmssp.SetCompatibilityLevel(1), ntlmssp.SetUserInfo(user, password))
+	if err != nil {
+		return nil, fmt.Errorf("error creating NTLMSSPClient, err=%w", err)
+	}
+	nnsConn, err := nns.DialNTLMSSP(socketAddr, ntlmsspClient, 10*time.Second)
+	if err != nil {
+		return nil, fmt.Errorf("error connecting with NTLMSSP to %s, err=%w", socketAddr, err)
+	}
+	output.PrintfFrameworkStatus("NTLMSSP connection to %s was successful", socketAddr)
+
+	return nnsConn, nil
 }