Small refactoring

internal/literals/obfuscators.go

@@ -53,10 +53,9 @@ func genRandIntSlice(max, count int) []int {
 	return indexes
 }
 
-var allOperators = [...]token.Token{token.XOR, token.ADD, token.SUB}
-
 func randOperator() token.Token {
-	return allOperators[mathrand.Intn(len(allOperators))]
+	var operatorTokens = [...]token.Token{token.XOR, token.ADD, token.SUB}
+	return operatorTokens[mathrand.Intn(len(operatorTokens))]
 }
 
 func evalOperator(t token.Token, x, y byte) byte {

internal/literals/split.go

@@ -57,12 +57,11 @@ func shuffleStmts(stmts ...ast.Stmt) []ast.Stmt {
 
 // Encrypt chunks based on key and position
 func encryptChunks(chunks [][]byte, op token.Token, key int) {
-	idx := 0
+	byteOffset := 0
-	for chunkIdx := range chunks {
+	for _, chunk := range chunks {
-		chunk := chunks[chunkIdx]
 		for i := range chunk {
-			chunk[i] = evalOperator(op, chunk[i], byte(key^idx))
+			chunk[i] = evalOperator(op, chunk[i], byte(key^byteOffset))
-			idx++
+			byteOffset++
 		}
 	}
 }
@@ -76,8 +75,6 @@ func (x split) obfuscate(data []byte) *ast.BlockStmt {
 		chunks = splitIntoRandomChunks(data)
 	}
 
-	decryptOp := randOperator()
-
 	// Generate indexes for cases chunk count + 1 decrypt case + 1 exit case
 	indexes := mathrand.Perm(len(chunks) + 2)
 
@@ -87,7 +84,9 @@ func (x split) obfuscate(data []byte) *ast.BlockStmt {
 	for i, index := range indexes[:len(indexes)-1] {
 		decryptKey ^= index * i
 	}
-	encryptChunks(chunks, decryptOp, decryptKey)
+
+	op := randOperator()
+	encryptChunks(chunks, op, decryptKey)
 
 	decryptIndex := indexes[len(indexes)-2]
 	exitIndex := indexes[len(indexes)-1]
@@ -107,7 +106,7 @@ func (x split) obfuscate(data []byte) *ast.BlockStmt {
 					Lhs: []ast.Expr{ah.IndexExpr("data", ah.Ident("y"))},
 					Tok: token.ASSIGN,
 					Rhs: []ast.Expr{
-						operatorToReversedBinaryExpr(decryptOp, ah.IndexExpr("data", ah.Ident("y")), ah.CallExpr(ah.Ident("byte"), &ast.BinaryExpr{
+						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"),

internal/literals/swap.go

@@ -59,14 +59,14 @@ func (x swap) obfuscate(data []byte) *ast.BlockStmt {
 	swapCount := generateSwapCount(len(data))
 	shiftKey := byte(mathrand.Intn(math.MaxUint8))
 
-	localKeyOp := randOperator()
+	op := randOperator()
 
 	positions := genRandIntSlice(len(data), swapCount)
 	for i := len(positions) - 2; i >= 0; i -= 2 {
 		// Generate local key for xor based on random key and byte position
 		localKey := byte(i) + byte(positions[i]^positions[i+1]) + shiftKey
-		// Swap bytes from i+1 to i and xor using local key
+		// Swap bytes from i+1 to i and encrypt using operator and local key
-		data[positions[i]], data[positions[i+1]] = evalOperator(localKeyOp, data[positions[i+1]], localKey), evalOperator(localKeyOp, data[positions[i]], localKey)
+		data[positions[i]], data[positions[i+1]] = evalOperator(op, data[positions[i+1]], localKey), evalOperator(op, data[positions[i]], localKey)
 	}
 
 	return ah.BlockStmt(
@@ -129,12 +129,21 @@ func (x swap) obfuscate(data []byte) *ast.BlockStmt {
 					},
 					Tok: token.ASSIGN,
 					Rhs: []ast.Expr{
-						operatorToReversedBinaryExpr(localKeyOp, ah.IndexExpr("data", ah.IndexExpr("positions", &ast.BinaryExpr{
+						operatorToReversedBinaryExpr(
-							X:  ah.Ident("i"),
+							op,
-							Op: token.ADD,
+							ah.IndexExpr("data",
-							Y:  ah.IntLit(1),
+								ah.IndexExpr("positions", &ast.BinaryExpr{
-						})), ah.Ident("localKey")),
+									X:  ah.Ident("i"),
-						operatorToReversedBinaryExpr(localKeyOp, ah.IndexExpr("data", ah.IndexExpr("positions", ah.Ident("i"))), ah.Ident("localKey")),
+									Op: token.ADD,
+									Y:  ah.IntLit(1),
+								}),
+							),
+							ah.Ident("localKey")),
+						operatorToReversedBinaryExpr(
+							op,
+							ah.IndexExpr("data", ah.IndexExpr("positions", ah.Ident("i"))),
+							ah.Ident("localKey"),
+						),
 					},
 				},
 			),

internal/literals/xor_shuffle.go

@@ -39,8 +39,8 @@ func (x xorShuffle) obfuscate(data []byte) *ast.BlockStmt {
 		args = append(args, operatorToReversedBinaryExpr(
 			operators[i],
 			ah.IndexExpr("fullData", ah.IntLit(shuffledIdxs[i])),
-			ah.IndexExpr("fullData", ah.IntLit(shuffledIdxs[len(data)+i]))),
+			ah.IndexExpr("fullData", ah.IntLit(shuffledIdxs[len(data)+i])),
-		)
+		))
 	}
 
 	return ah.BlockStmt(