small fixes

internal/literals/obfuscators.go

@@ -45,6 +45,12 @@ func genRandBytes(buffer []byte) {
 	}
 }
 
+func genRandByte() byte {
+	bytes := make([]byte, 1)
+	genRandBytes(bytes)
+	return bytes[0]
+}
+
 func genRandIntSlice(max, count int) []int {
 	indexes := make([]int, count)
 	for i := 0; i < count; i++ {
@@ -54,7 +60,7 @@ func genRandIntSlice(max, count int) []int {
 }
 
 func randOperator() token.Token {
-	var operatorTokens = [...]token.Token{token.XOR, token.ADD, token.SUB}
+	operatorTokens := [...]token.Token{token.XOR, token.ADD, token.SUB}
 	return operatorTokens[mathrand.Intn(len(operatorTokens))]
 }
 

internal/literals/split.go

@@ -56,11 +56,11 @@ func shuffleStmts(stmts ...ast.Stmt) []ast.Stmt {
 }
 
 // Encrypt chunks based on key and position
-func encryptChunks(chunks [][]byte, op token.Token, key int) {
+func encryptChunks(chunks [][]byte, op token.Token, key byte) {
 	byteOffset := 0
 	for _, chunk := range chunks {
 		for i, b := range chunk {
-			chunk[i] = evalOperator(op, b, byte(key^byteOffset))
+			chunk[i] = evalOperator(op, b, key^byte(byteOffset))
 			byteOffset++
 		}
 	}
@@ -78,11 +78,11 @@ func (x split) obfuscate(data []byte) *ast.BlockStmt {
 	// Generate indexes for cases chunk count + 1 decrypt case + 1 exit case
 	indexes := mathrand.Perm(len(chunks) + 2)
 
-	decryptKeyInitial := mathrand.Int()
+	decryptKeyInitial := genRandByte()
 	decryptKey := decryptKeyInitial
 	// Calculate decrypt key based on indexes and position. Ignore exit index
 	for i, index := range indexes[:len(indexes)-1] {
-		decryptKey ^= index * i
+		decryptKey ^= byte(index * i)
 	}
 
 	op := randOperator()
@@ -106,11 +106,15 @@ func (x split) obfuscate(data []byte) *ast.BlockStmt {
 					Lhs: []ast.Expr{ah.IndexExpr("data", ah.Ident("y"))},
 					Tok: token.ASSIGN,
 					Rhs: []ast.Expr{
-						operatorToReversedBinaryExpr(op, ah.IndexExpr("data", ah.Ident("y")), ah.CallExpr(ah.Ident("byte"), &ast.BinaryExpr{
-							X:  ah.Ident("decryptKey"),
-							Op: token.XOR,
-							Y:  ah.Ident("y"),
-						})),
+						operatorToReversedBinaryExpr(
+							op,
+							ah.IndexExpr("data", ah.Ident("y")),
+							ah.CallExpr(ah.Ident("byte"), &ast.BinaryExpr{
+								X:  ah.Ident("decryptKey"),
+								Op: token.XOR,
+								Y:  ah.Ident("y"),
+							}),
+						),
 					},
 				}),
 			},
@@ -168,7 +172,7 @@ func (x split) obfuscate(data []byte) *ast.BlockStmt {
 		&ast.AssignStmt{
 			Lhs: []ast.Expr{ah.Ident("decryptKey")},
 			Tok: token.DEFINE,
-			Rhs: []ast.Expr{ah.IntLit(decryptKeyInitial)},
+			Rhs: []ast.Expr{ah.IntLit(int(decryptKeyInitial))},
 		},
 		&ast.ForStmt{
 			Init: &ast.AssignStmt{

internal/literals/swap.go

@@ -57,7 +57,7 @@ func generateSwapCount(dataLen int) int {
 
 func (x swap) obfuscate(data []byte) *ast.BlockStmt {
 	swapCount := generateSwapCount(len(data))
-	shiftKey := byte(mathrand.Intn(math.MaxUint8))
+	shiftKey := genRandByte()
 
 	op := randOperator()
 
@@ -138,7 +138,8 @@ func (x swap) obfuscate(data []byte) *ast.BlockStmt {
 									Y:  ah.IntLit(1),
 								}),
 							),
-							ah.Ident("localKey")),
+							ah.Ident("localKey"),
+						),
 						operatorToReversedBinaryExpr(
 							op,
 							ah.IndexExpr("data", ah.IndexExpr("positions", ah.Ident("i"))),

internal/literals/xor_seed.go

@@ -13,10 +13,7 @@ type xorSeed struct{}
 var _ obfuscator = xorSeed{}
 
 func (x xorSeed) obfuscate(data []byte) *ast.BlockStmt {
-	preSeed := make([]byte, 1)
-	genRandBytes(preSeed)
-
-	seed := preSeed[0]
+	seed := genRandByte()
 	originalSeed := seed
 
 	op := randOperator()