Add test for literal obfuscators (#80)

* Combine literals-all-obfuscators.txt nad literals.txt
Rewrite literals.txt logic

* Remove unused \s

* Refactoring and add float ast helpers

internal/asthelper/asthelper.go

@@ -28,6 +28,22 @@ func IntLit(value int) *ast.BasicLit {
 	}
 }
 
+// Float32Lit returns an ast.BasicLit of kind FLOAT, 32 bit
+func Float32Lit(value float32) *ast.BasicLit {
+	return &ast.BasicLit{
+		Kind:  token.FLOAT,
+		Value: strconv.FormatFloat(float64(value), 'f', -1, 32),
+	}
+}
+
+// Float64Lit returns an ast.BasicLit of kind FLOAT, 64 bit
+func Float64Lit(value float64) *ast.BasicLit {
+	return &ast.BasicLit{
+		Kind:  token.FLOAT,
+		Value: strconv.FormatFloat(value, 'f', -1, 64),
+	}
+}
+
 // IndexExpr "name[index]"
 func IndexExpr(name string, index ast.Expr) *ast.IndexExpr {
 	return &ast.IndexExpr{

main_test.go

@@ -4,11 +4,16 @@
 package main
 
 import (
+	"encoding/base32"
 	"encoding/binary"
 	"flag"
 	"fmt"
+	"go/ast"
+	"go/printer"
+	"go/token"
 	"io"
 	"math"
+	mathrand "math/rand"
 	"os"
 	"os/exec"
 	"path/filepath"
@@ -21,6 +26,8 @@ import (
 	"github.com/rogpeppe/go-internal/goproxytest"
 	"github.com/rogpeppe/go-internal/gotooltest"
 	"github.com/rogpeppe/go-internal/testscript"
+
+	ah "mvdan.cc/garble/internal/asthelper"
 )
 
 var proxyURL string
@@ -77,10 +84,11 @@ func TestScripts(t *testing.T) {
 			return nil
 		},
 		Cmds: map[string]func(ts *testscript.TestScript, neg bool, args []string){
-			"binsubstr":   binsubstr,
-			"bincmp":      bincmp,
-			"binsubint":   binsubint,
-			"binsubfloat": binsubfloat,
+			"binsubstr":         binsubstr,
+			"bincmp":            bincmp,
+			"binsubint":         binsubint,
+			"binsubfloat":       binsubfloat,
+			"generate-literals": generateLiterals,
 		},
 		UpdateScripts: *update,
 	}
@@ -132,6 +140,14 @@ func readFile(ts *testscript.TestScript, file string) string {
 	return cachedBinary.content
 }
 
+func createFile(ts *testscript.TestScript, path string) *os.File {
+	file, err := os.Create(ts.MkAbs(path))
+	if err != nil {
+		ts.Fatalf("%v", err)
+	}
+	return file
+}
+
 func binsubstr(ts *testscript.TestScript, neg bool, args []string) {
 	if len(args) < 2 {
 		ts.Fatalf("usage: binsubstr file substr...")
@@ -245,6 +261,70 @@ func bincmp(ts *testscript.TestScript, neg bool, args []string) {
 	}
 }
 
+var literalGenerators = []func() *ast.BasicLit{
+	func() *ast.BasicLit {
+		buffer := make([]byte, 1+mathrand.Intn(255))
+		_, err := mathrand.Read(buffer)
+		if err != nil {
+			panic(err)
+		}
+		str := base32.StdEncoding.EncodeToString(buffer)
+		return ah.StringLit(str)
+	},
+	func() *ast.BasicLit {
+		i := mathrand.Int()
+		return ah.IntLit(i)
+	},
+	func() *ast.BasicLit {
+		return ah.Float64Lit(mathrand.NormFloat64())
+	},
+	func() *ast.BasicLit {
+		return ah.Float32Lit(mathrand.Float32())
+	},
+}
+
+func generateLiterals(ts *testscript.TestScript, neg bool, args []string) {
+	if neg {
+		ts.Fatalf("unsupported: ! generate-literals")
+	}
+	if len(args) != 3 {
+		ts.Fatalf("usage: generate-literals file literalCount funcName")
+	}
+
+	codePath, funcName := args[0], args[2]
+
+	literalCount, err := strconv.Atoi(args[1])
+	if err != nil {
+		ts.Fatalf("%v", err)
+	}
+
+	var statements []ast.Stmt
+	for i := 0; i < literalCount; i++ {
+		literal := literalGenerators[i%len(literalGenerators)]()
+		statements = append(statements, ah.ExprStmt(ah.CallExpr(ah.Ident("println"), literal)))
+	}
+
+	file := &ast.File{
+		Name: ah.Ident("main"),
+		Decls: []ast.Decl{
+			&ast.FuncDecl{
+				Name: ah.Ident(funcName),
+				Type: &ast.FuncType{
+					Params: &ast.FieldList{},
+				},
+				Body: ah.BlockStmt(statements...),
+			},
+		},
+	}
+
+	codeFile := createFile(ts, codePath)
+	defer codeFile.Close()
+
+	if err := printer.Fprint(codeFile, token.NewFileSet(), file); err != nil {
+		ts.Fatalf("%v", err)
+	}
+}
+
 func TestFlagValue(t *testing.T) {
 	t.Parallel()
 	tests := []struct {

testdata/scripts/literals.txt

@@ -1,19 +1,21 @@
+# Generate and write random literals into a separate file
+generate-literals extraLiterals.go 500 printExtraLiterals
+
 go build
 exec ./main$exe
-binsubstr main$exe 'Lorem' 'dolor' 'second assign' 'First Line' 'Second Line' 'map value' 'to obfuscate' 'also obfuscate' 'stringTypeField String' 
 
+binsubstr main$exe 'Lorem' 'dolor' 'second assign' 'First Line' 'Second Line' 'map value' 'to obfuscate' 'also obfuscate' 'stringTypeField String'
 binsubint main$exe '-7081390804778629748' '-301627827188279046' '7679634459002713443'
 binsubfloat main$exe '3684433217126772357.33' '-9015867427900753906'
-cmp stderr main.stderr
+
 cp stderr normal.stderr
+
 garble -literals build
 exec ./main$exe
-cmp stderr main.stderr
 cmp stderr normal.stderr
-! binsubstr main$exe 'garbleDecrypt' 'Lorem' 'dolor' 'first assign' 'second assign' 'First Line' 'Second Line' 'map value' 'to obfuscate' 'also obfuscate' 'stringTypeField String' 
 
 binsubstr main$exe 'Skip this block' 'also skip this' 'skip typed const' 'skip typed var' 'skip typed var assign' 'stringTypeField strType' 'stringType lambda func return' 'testMap1 key' 'testMap2 key' 'testMap3 key' 'testMap1 value' 'testMap3 value' 'testMap1 new value' 'testMap3 new value' 'stringType func param' 'stringType return' 'skip untyped const'
-
+! binsubstr main$exe 'garbleDecrypt' 'Lorem' 'dolor' 'first assign' 'second assign' 'First Line' 'Second Line' 'map value' 'to obfuscate' 'also obfuscate' 'stringTypeField String'
 ! binsubint main$exe '-7081390804778629748' '-301627827188279046' '7679634459002713443'
 ! binsubfloat main$exe '3684433217126772357.33' '-9015867427900753906'
 [short] stop # checking that the build is reproducible is slow
@@ -24,6 +26,23 @@ rm main$exe
 garble -literals build
 bincmp main$exe main_old$exe
 
+# Also check that the binary is different from previous builds.
+rm main$exe
+garble -literals -debugdir=.obf-src -seed=8J+Ri/Cfh6fwn4e+ build
+! bincmp main$exe main_old$exe
+
+exec ./main$exe
+cmp stderr normal.stderr
+
+# Check obfuscators
+
+# Xor obfuscator. Detect a[i] = a[i] ^ b[i]
+grep '^\s+\w+\[\w+\] = \w+\[\w+\] \^ \w+$' .obf-src/main/z0.go
+
+# Swap obfuscator. Detect [...]byte|uint16|uint32|uint64{...}
+grep '^\s+\w+ := \[\.{3}\](byte|uint16|uint32|uint64)\{[0-9\s,]+\}$' .obf-src/main/z0.go
+
+
 -- go.mod --
 module test/main
 -- main.go --
@@ -99,6 +118,7 @@ func main() {
 	byteTest()
 	numTest()
 	boolTest()
+	printExtraLiterals()
 }
 
 type stringType string
@@ -280,38 +300,4 @@ func boolTest() {
 	f = false
 
 	println(a, b, c, d, e, f)
-}
-
--- main.stderr --
-Lorem true
-First Line
-Second Line total string
-dolor
-second assign
-
-😅 😅
-to obfuscate also obfuscate
-new value
-another literal
-Skip this block also skip this
-1 0 1
-skip untyped const
-skip typed const skip typed var skip typed var assign
-stringTypeField String stringTypeField strType
-stringType lambda func return
-stringType func param
-stringType return
-foo
-foo
-3 6
-12, 13, 
-12, 13, 
-12, 13, 
-12, 13, 0, 0, 
-1 3 2824583991413579605 4 5 3735714531481032066
--7081390804778629748 -301627827188279046 -122 3534 333453534 4568766098255857483
-7679634459002713443 34 3534 333453534 5490982829161518439 7364326871810921708
-+3.684433e+018 -9.015867e+018 -4.354535e+011 +6.338508e+012
-(-4.354535e+011+0.000000e+000i) (+1.000000e+000+4.000000e+000i)
-1337 +1.337000e+003 4919 +4.919000e+003 735 735
-true false false true true false
+}