Add LinkMode() to binary implementation

pkg/binary/binary.go

@@ -56,13 +56,10 @@ type Options struct {
 	Path string
 }
 
-// DefaultOptions set of options
-var DefaultOptions = &Options{}
-
 // New creates a new binary instance.
 func New(filePath string) (bin *Binary, err error) {
 	// Get the right implementation for the specified file
-	return NewWithOptions(filePath, DefaultOptions)
+	return NewWithOptions(filePath, &Options{Path: filePath})
 }
 
 // NewWithOptions creates a new binary with the specified options
@@ -121,6 +118,9 @@ type binaryImplementation interface {
 
 	// GetOS Returns a string with the GOOS of the binary
 	OS() string
+
+	// LinkMode returns the linking mode of the binary.
+	LinkMode() (LinkMode, error)
 }
 
 // SetImplementation sets the implementation to handle this sort of executable
@@ -138,6 +138,20 @@ func (b *Binary) OS() string {
 	return b.binaryImplementation.OS()
 }
 
+// LinkMode is the enum for all available linking modes.
+type LinkMode string
+
+const (
+	LinkModeUnknown LinkMode = "unknown"
+	LinkModeStatic  LinkMode = "static"
+	LinkModeDynamic LinkMode = "dynamic"
+)
+
+// LinkMode returns the linking mode of the binary.
+func (b *Binary) LinkMode() (LinkMode, error) {
+	return b.binaryImplementation.LinkMode()
+}
+
 // ContainsStrings searches the printable strings un a binary file
 func (b *Binary) ContainsStrings(s ...string) (match bool, err error) {
 	// We cannot search for 0 items:

pkg/binary/elf.go

@@ -18,6 +18,7 @@ package binary
 
 import (
 	"bufio"
+	debugelf "debug/elf"
 	"encoding/binary"
 	"fmt"
 	"os"
@@ -55,7 +56,8 @@ func NewELFBinary(filePath string, opts *Options) (*ELFBinary, error) {
 	}
 
 	return &ELFBinary{
-		Header: header,
+		Header:  header,
+		Options: opts,
 	}, nil
 }
 
@@ -170,3 +172,27 @@ func (elf *ELFBinary) Arch() string {
 func (elf *ELFBinary) OS() string {
 	return LINUX
 }
+
+// LinkMode returns the linking mode of the binary.
+func (elf *ELFBinary) LinkMode() (LinkMode, error) {
+	file, err := os.Open(elf.Options.Path)
+	if err != nil {
+		return LinkModeUnknown, fmt.Errorf("open binary path: %w", err)
+	}
+
+	elfFile, err := debugelf.NewFile(file)
+	if err != nil {
+		return LinkModeUnknown, fmt.Errorf("unable to parse elf: %w", err)
+	}
+
+	for _, programHeader := range elfFile.Progs {
+		// If the elf program header refers to an interpreter, then the binary
+		// is not statically linked. See `file` implementation reference:
+		// https://github.com/file/file/blob/FILE5_36/src/readelf.c#L1581
+		if programHeader.Type == debugelf.PT_INTERP {
+			return LinkModeDynamic, nil
+		}
+	}
+
+	return LinkModeStatic, nil
+}

pkg/binary/mach-o.go

@@ -178,3 +178,8 @@ func (macho *MachOBinary) Arch() string {
 func (macho *MachOBinary) OS() string {
 	return DARWIN
 }
+
+// LinkMode returns the linking mode of the binary.
+func (macho *MachOBinary) LinkMode() (LinkMode, error) {
+	return LinkModeUnknown, nil
+}

pkg/binary/windows.go

@@ -198,3 +198,8 @@ func (pe *PEBinary) Arch() string {
 func (pe *PEBinary) OS() string {
 	return WIN
 }
+
+// LinkMode returns the linking mode of the binary.
+func (pe *PEBinary) LinkMode() (LinkMode, error) {
+	return LinkModeUnknown, nil
+}

pkg/release/binaries.go

@@ -145,6 +145,15 @@ func (impl *defaultArtifactCheckerImpl) CheckVersionArch(
 				binData.Path, binData.Arch, binData.Platform, bin.Arch(), bin.OS(),
 			)
 		}
+
+		linkMode, err := bin.LinkMode()
+		if err != nil {
+			logrus.Warnf("Unable to get linkmode from binary %s: %v", binData.Path, err)
+		} else if linkMode == binary.LinkModeDynamic {
+			// TODO: fail hard if not all binaries are static (or unknown)
+			// Ref: https://github.com/kubernetes/release/issues/2786
+			logrus.Warnf("Binary is dynamically linked, which should be nothing we release: %s", binData.Path)
+		}
 	}
 	return nil
 }