Changed packer to not hold entire binary in RAM

Author: Foosec

Diff for: main.go

@@ -1,69 +1,32 @@
 package main
 
 import (
-	"bytes"
-	b64 "encoding/base64"
 	"flag"
 	"io"
 	"log"
 	"os"
-	"strings"
-)
-
-const (
-	winPathI = iota
-	linPathI = iota
-	macPathI = iota
 )
 
 func main() {
 
-	paths := make([]string, 3)
-
-	flag.StringVar(&paths[winPathI], "w", "", "Windows executable path")
-	flag.StringVar(&paths[linPathI], "l", "", "Linux executable path")
-	flag.StringVar(&paths[macPathI], "m", "", "MacOS executable path")
+	paths := map[string]*string{
+		"@binary_lin@": flag.String("l", "", "Linux executable path"),
+		"@binary_win@": flag.String("w", "", "Windows executable path"),
+		"@binary_mac@": flag.String("m", "", "MacOS executable path"),
+	}
 
 	pOut := flag.String("o", "CrossBin.ps1", "Output file")
 
 	flag.Parse()
 
-	r, err := packBinaries(paths)
-	if err != nil {
-		log.Fatal(err)
+	packer := Packer{
+		PlacePath: paths,
 	}
+	packer.Init()
 
 	f, err := os.Create(*pOut)
 	if err != nil {
 		log.Fatal(err)
 	}
-	io.Copy(f, r)
-}
-
-func packBinaries(paths []string) (io.Reader, error) {
-
-	templatePlaceholders := []string{"@binary_win@", "@binary_lin@", "@binary_mac@"}
-
-	script, err := os.ReadFile("script.template")
-	if err != nil {
-		return nil, err
-	}
-
-	for i, p := range paths {
-
-		if p == "" {
-			script = []byte(strings.Replace(string(script), templatePlaceholders[i], "", 1))
-			continue
-		}
-
-		bin, err := os.ReadFile(p)
-		if err != nil {
-			return nil, err
-		}
-		sbin := b64.StdEncoding.EncodeToString(bin)
-		script = []byte(strings.Replace(string(script), templatePlaceholders[i], sbin, 1))
-	}
-
-	return bytes.NewReader(script), nil
-
+	io.Copy(f, &packer)
 }

Diff for: packer.go

@@ -0,0 +1,104 @@
+package main
+
+import (
+	"bytes"
+	"encoding/base64"
+	"io"
+	"log"
+	"os"
+	"sort"
+)
+
+type Packer struct {
+	PlacePath map[string]*string
+
+	Chunks   []io.Reader
+	curChunk int
+	curPos   int
+
+	script []byte
+}
+
+func (p *Packer) Init() error {
+
+	sb, err := os.ReadFile("script.template")
+	if err != nil {
+		return err
+	}
+	p.script = sb
+
+	plocs := make(map[int]string)
+	//Split by all placeholder
+	for k, _ := range p.PlacePath {
+		i := bytes.Index(p.script, []byte(k))
+		plocs[i] = k
+	}
+
+	var indexes []int
+	for k, _ := range plocs {
+		indexes = append(indexes, k)
+	}
+	sort.Ints(indexes)
+
+	scriptReader := bytes.NewBuffer(p.script)
+	offset := 0
+	for _, i := range indexes {
+
+		var buf []byte
+		buf = make([]byte, i-offset)
+		r, err := scriptReader.Read(buf)
+		if err != nil {
+			log.Println(err)
+			break
+		}
+		p.Chunks = append(p.Chunks, bytes.NewBuffer(buf))
+
+		log.Println(plocs[i])
+		fp := *p.PlacePath[plocs[i]]
+		if fp != "" {
+			f, err := os.Open(fp)
+			if err != nil {
+				log.Println(err)
+			}
+
+			pr, pw := io.Pipe()
+			bw := base64.NewEncoder(base64.StdEncoding, pw)
+			go func() {
+				io.Copy(bw, f)
+				bw.Close()
+				pw.Close()
+			}()
+
+			p.Chunks = append(p.Chunks, pr)
+		}
+
+		offset += r
+		r, _ = scriptReader.Read(make([]byte, len(plocs[i])))
+		offset += r
+	}
+	buf := make([]byte, len(p.script)-offset)
+	scriptReader.Read(buf)
+	p.Chunks = append(p.Chunks, bytes.NewBuffer(buf))
+
+	return nil
+}
+
+func (p *Packer) Read(dst []byte) (int, error) {
+
+	total := 0
+	for total < len(dst) {
+
+		r, err := p.Chunks[p.curChunk].Read(dst[total:])
+		if err == io.EOF {
+			if p.curChunk == len(p.Chunks)-1 {
+				return total + r, io.EOF
+			}
+			p.curChunk += 1
+		} else if err != nil {
+			log.Fatal("error:", err)
+		}
+		total += r
+	}
+
+	return total, nil
+}