From 3bb6939bf6762eeb6c52c9a9cfbd334bbdaf9cc4 Mon Sep 17 00:00:00 2001
From: pagran <67878280+pagran@users.noreply.github.com>
Date: Tue, 1 Apr 2025 15:53:01 +0200
Subject: [PATCH] update

---
 internal/asthelper/asthelper.go  | 20 ++------------------
 internal/literals/literals.go    | 10 +++++-----
 internal/literals/obfuscators.go |  2 +-
 3 files changed, 8 insertions(+), 24 deletions(-)

diff --git a/internal/asthelper/asthelper.go b/internal/asthelper/asthelper.go
index 57158f6..2198f57 100644
--- a/internal/asthelper/asthelper.go
+++ b/internal/asthelper/asthelper.go
@@ -43,24 +43,8 @@ func CallExpr(fun ast.Expr, args ...ast.Expr) *ast.CallExpr {
 	}
 }
 
-// LambdaCall "func() resultType {block}()"
-func LambdaCall(resultType ast.Expr, block *ast.BlockStmt) *ast.CallExpr {
-	funcLit := &ast.FuncLit{
-		Type: &ast.FuncType{
-			Params: &ast.FieldList{},
-			Results: &ast.FieldList{
-				List: []*ast.Field{
-					{Type: resultType},
-				},
-			},
-		},
-		Body: block,
-	}
-	return CallExpr(funcLit)
-}
-
-// LambdaCallParams "func(params) resultType {block}(args)"
-func LambdaCallParams(params *ast.FieldList, resultType ast.Expr, block *ast.BlockStmt, args []ast.Expr) *ast.CallExpr {
+// LambdaCall "func(params) resultType {block}(args)"
+func LambdaCall(params *ast.FieldList, resultType ast.Expr, block *ast.BlockStmt, args []ast.Expr) *ast.CallExpr {
 	funcLit := &ast.FuncLit{
 		Type: &ast.FuncType{
 			Params: params,
diff --git a/internal/literals/literals.go b/internal/literals/literals.go
index 015047c..f761eb3 100644
--- a/internal/literals/literals.go
+++ b/internal/literals/literals.go
@@ -242,7 +242,7 @@ func obfuscateString(obfRand *obfRand, data string) *ast.CallExpr {
 
 	block.List = append(block.List, ah.ReturnStmt(ah.CallExpr(ast.NewIdent("string"), ast.NewIdent("data"))))
 
-	return ah.LambdaCallParams(params, ast.NewIdent("string"), block, args)
+	return ah.LambdaCall(params, ast.NewIdent("string"), block, args)
 }
 
 func obfuscateByteSlice(obfRand *obfRand, isPointer bool, data []byte) *ast.CallExpr {
@@ -257,13 +257,13 @@ func obfuscateByteSlice(obfRand *obfRand, isPointer bool, data []byte) *ast.Call
 			Op: token.AND,
 			X:  ast.NewIdent("data"),
 		}))
-		return ah.LambdaCallParams(params, &ast.StarExpr{
+		return ah.LambdaCall(params, &ast.StarExpr{
 			X: &ast.ArrayType{Elt: ast.NewIdent("byte")},
 		}, block, args)
 	}
 
 	block.List = append(block.List, ah.ReturnStmt(ast.NewIdent("data")))
-	return ah.LambdaCallParams(params, &ast.ArrayType{Elt: ast.NewIdent("byte")}, block, args)
+	return ah.LambdaCall(params, &ast.ArrayType{Elt: ast.NewIdent("byte")}, block, args)
 }
 
 func obfuscateByteArray(obfRand *obfRand, isPointer bool, data []byte, length int64) *ast.CallExpr {
@@ -311,10 +311,10 @@ func obfuscateByteArray(obfRand *obfRand, isPointer bool, data []byte, length in
 	block.List = append(block.List, sliceToArray...)
 
 	if isPointer {
-		return ah.LambdaCallParams(params, &ast.StarExpr{X: arrayType}, block, args)
+		return ah.LambdaCall(params, &ast.StarExpr{X: arrayType}, block, args)
 	}
 
-	return ah.LambdaCallParams(params, arrayType, block, args)
+	return ah.LambdaCall(params, arrayType, block, args)
 }
 
 func getNextObfuscator(obfRand *obfRand, size int) obfuscator {
diff --git a/internal/literals/obfuscators.go b/internal/literals/obfuscators.go
index 0408c8f..470cc3b 100644
--- a/internal/literals/obfuscators.go
+++ b/internal/literals/obfuscators.go
@@ -229,7 +229,7 @@ func dataToByteSliceWithExtKeys(obfRand *mathrand.Rand, data []byte, extKeys []*
 	slices.Reverse(stmts)
 
 	stmts = append([]ast.Stmt{ah.AssignDefineStmt(ast.NewIdent("data"), ah.DataToByteSlice(data))}, append(stmts, ah.ReturnStmt(ast.NewIdent("data")))...)
-	return ah.LambdaCall(&ast.ArrayType{Elt: ast.NewIdent("byte")}, ah.BlockStmt(stmts...))
+	return ah.LambdaCall(nil, &ast.ArrayType{Elt: ast.NewIdent("byte")}, ah.BlockStmt(stmts...), nil)
 }
 
 // dataToByteSliceWithExtKeys scramble and turns a byte into an AST expression like: