Add makefile + better units in output

Author: FizzyGalacticus

.gitignore

@@ -3,6 +3,7 @@ test/
 
 # Binary
 steg-go
+dist/
 
 # IDE
 .vscode/

Makefile

@@ -0,0 +1,37 @@
+BINARY_NAME := steg-go
+DIST_DIR := dist
+VERSION ?= dev
+
+GO := go
+GOFLAGS := -trimpath
+LDFLAGS := -s -w
+
+.PHONY: all build build-linux build-macos build-windows build-wasm build-all clean
+
+all: build-all
+
+build: ## Build for the current platform
+	$(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(BINARY_NAME) .
+
+build-linux: ## Build static Linux binary (amd64)
+	mkdir -p $(DIST_DIR)
+	CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(DIST_DIR)/$(BINARY_NAME)-linux-amd64 .
+
+build-macos: ## Build macOS binary (amd64 + arm64)
+	mkdir -p $(DIST_DIR)
+	CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(DIST_DIR)/$(BINARY_NAME)-darwin-amd64 .
+	CGO_ENABLED=0 GOOS=darwin GOARCH=arm64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(DIST_DIR)/$(BINARY_NAME)-darwin-arm64 .
+
+build-windows: ## Build Windows binary (amd64)
+	mkdir -p $(DIST_DIR)
+	CGO_ENABLED=0 GOOS=windows GOARCH=amd64 $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(DIST_DIR)/$(BINARY_NAME)-windows-amd64.exe .
+
+build-wasm: ## Build WebAssembly binary (js/wasm)
+	mkdir -p $(DIST_DIR)
+	GOOS=js GOARCH=wasm $(GO) build $(GOFLAGS) -ldflags "$(LDFLAGS)" -o $(DIST_DIR)/$(BINARY_NAME)-js-wasm.wasm .
+
+build-all: build-linux build-macos build-windows build-wasm ## Build all target platforms
+
+clean: ## Remove build artifacts
+	rm -rf $(DIST_DIR)
+	rm -f $(BINARY_NAME)

main.go

@@ -61,6 +61,8 @@ func main() {
 			os.Exit(0)
 		}
 
+		fmt.Printf("Decoded hidden payload: %s\n", stego.FormatBytes(uint64(len(data))))
+
 		err = stego.ExtractTarGz(data, output)
 		if err != nil {
 			fmt.Fprintf(os.Stderr, "Error extracting archive: %v\n", err)
@@ -82,7 +84,7 @@ func main() {
 				fmt.Fprintf(os.Stderr, "Error creating archive: %v\n", err)
 				os.Exit(1)
 			}
-			fmt.Printf("Created archive with preserved directory structure\n")
+			fmt.Printf("Created archive with preserved directory structure: %s\n", stego.FormatBytes(uint64(len(archiveData))))
 		}
 
 		// Encode data into image using LSB steganography

stego/archive.go

@@ -13,7 +13,10 @@ import (
 // CreateTarGzWithStructure creates a tar.gz archive preserving directory structure
 func CreateTarGzWithStructure(paths []string) ([]byte, error) {
 	var buf bytes.Buffer
-	gzWriter := gzip.NewWriter(&buf)
+	gzWriter, err := gzip.NewWriterLevel(&buf, gzip.BestCompression)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create gzip writer: %v", err)
+	}
 	tarWriter := tar.NewWriter(gzWriter)
 
 	for _, path := range paths {
@@ -34,9 +37,20 @@ func CreateTarGzWithStructure(paths []string) ([]byte, error) {
 				if err != nil {
 					relPath = filePath
 				}
+				relPath = filepath.ToSlash(relPath)
 
 				if info.IsDir() {
-					// Add directory entry
+					// Add directory headers only for empty directories.
+					// Non-empty directories are implicitly created during extraction
+					// from file paths and omitting them keeps the archive smaller.
+					isEmpty, err := isDirEmpty(filePath)
+					if err != nil {
+						return err
+					}
+					if !isEmpty {
+						return nil
+					}
+
 					header := &tar.Header{
 						Name:     relPath + "/",
 						Mode:     int64(info.Mode()),
@@ -97,6 +111,8 @@ func addFileToTarWithName(tarWriter *tar.Writer, filePath, tarName string) error
 	}
 	defer file.Close()
 
+	tarName = filepath.ToSlash(tarName)
+
 	stat, err := file.Stat()
 	if err != nil {
 		return err
@@ -117,6 +133,14 @@ func addFileToTarWithName(tarWriter *tar.Writer, filePath, tarName string) error
 	return err
 }
 
+func isDirEmpty(path string) (bool, error) {
+	entries, err := os.ReadDir(path)
+	if err != nil {
+		return false, err
+	}
+	return len(entries) == 0, nil
+}
+
 // ExtractTarGz extracts a tar.gz archive to a directory
 func ExtractTarGz(data []byte, destDir string) error {
 	gzReader, err := gzip.NewReader(bytes.NewReader(data))

stego/size.go

@@ -0,0 +1,21 @@
+package stego
+
+import "fmt"
+
+var sizeUnits = []string{"B", "KB", "MB", "GB", "TB", "PB"}
+
+// FormatBytes returns a human-readable byte size using base-1024 units.
+func FormatBytes(n uint64) string {
+	if n < 1024 {
+		return fmt.Sprintf("%d B", n)
+	}
+
+	value := float64(n)
+	unitIndex := 0
+	for value >= 1024 && unitIndex < len(sizeUnits)-1 {
+		value /= 1024
+		unitIndex++
+	}
+
+	return fmt.Sprintf("%.2f %s", value, sizeUnits[unitIndex])
+}

stego/stego.go

@@ -16,9 +16,11 @@ func EncodeData(img image.Image, data []byte) (image.Image, error) {
 	// We need 4 bytes for length + actual data
 	availableBits := width * height * 3
 	requiredBits := (len(data) + 4) * 8 // 4 bytes for length prefix
+	availableBytes := availableBits / 8
+	requiredBytes := len(data) + 4
 
 	if requiredBits > availableBits {
-		return nil, fmt.Errorf("image too small: need %d bits, have %d bits", requiredBits, availableBits)
+		return nil, fmt.Errorf("image too small: need %s, have %s capacity", FormatBytes(uint64(requiredBytes)), FormatBytes(uint64(availableBytes)))
 	}
 
 	// Create a new RGBA image
@@ -140,7 +142,7 @@ func DecodeData(img image.Image) ([]byte, error) {
 
 	// Sanity check
 	if dataLength == 0 || dataLength > 100*1024*1024 { // Max 100MB
-		return nil, fmt.Errorf("invalid data length: %d", dataLength)
+		return nil, fmt.Errorf("invalid data length: %s", FormatBytes(uint64(dataLength)))
 	}
 
 	// Extract the actual data