初探 Golang 代码混淆

func runBuild(ctx context.Context, cmd *base.Command, args []string) {    ...  var b Builder  ...  pkgs := load.PackagesAndErrors(ctx, args)  ...    a := &Action{Mode: "go build"}    for _, p := range pkgs {        a.Deps = append(a.Deps, b.AutoAction(ModeBuild, depMode, p))    }    ...    b.Do(ctx, a)}

// An Action represents a single action in the action graph.type Action struct {    Mode     string         // description of action operation    Package  *load.Package  // the package this action works on    Deps     []*Action      // actions that must happen before this one    Func     func(*Builder, context.Context, *Action) error // the action itself (nil = no-op)    ...}

for _, p1 := range p.Internal.Imports {    a.Deps = append(a.Deps, b.CompileAction(depMode, depMode, p1))}

a := &Action{  Mode: "build",  Func: (*Builder).build,  ...}
a := &Action{  Mode: "link",  Func: (*Builder).link,  ...}...

// src/cmd/go/internal/work/exec.gotype toolchain interface {    // gc runs the compiler in a specific directory on a set of files    // and returns the name of the generated output file.    gc(b *Builder, a *Action, archive string, importcfg, embedcfg []byte, symabis string, asmhdr bool, gofiles []string) (ofile string, out []byte, err error)    // cc runs the toolchain's C compiler in a directory on a C file    // to produce an output file.    cc(b *Builder, a *Action, ofile, cfile string) error    // asm runs the assembler in a specific directory on specific files    // and returns a list of named output files.    asm(b *Builder, a *Action, sfiles []string) ([]string, error)    // symabis scans the symbol ABIs from sfiles and returns the    // path to the output symbol ABIs file, or "" if none.    symabis(b *Builder, a *Action, sfiles []string) (string, error)    // pack runs the archive packer in a specific directory to create    // an archive from a set of object files.    // typically it is run in the object directory.    pack(b *Builder, a *Action, afile string, ofiles []string) error    // ld runs the linker to create an executable starting at mainpkg.    ld(b *Builder, root *Action, out, importcfg, mainpkg string) error    // ldShared runs the linker to create a shared library containing the pkgs built by toplevelactions    ldShared(b *Builder, root *Action, toplevelactions []*Action, out, importcfg string, allactions []*Action) error
    compiler() string    linker() string}

func init() {    switch build.Default.Compiler {    case "gc", "gccgo":        buildCompiler{}.Set(build.Default.Compiler)    }}
func (c buildCompiler) Set(value string) error {    switch value {    case "gc":        BuildToolchain = gcToolchain{}    case "gccgo":        BuildToolchain = gccgoToolchain{}  ...}

func (gcToolchain) gc(b *Builder, a *Action, archive string, importcfg, embedcfg []byte, symabis string, asmhdr bool, gofiles []string) (ofile string, output []byte, err error) {    // ...    // 拼接参数    // ...
    args := []interface{}{cfg.BuildToolexec, base.Tool("compile"), "-o", ofile, "-trimpath", a.trimpath(), gcflags, gcargs, "-D", p.Internal.LocalPrefix}
    // ...
    output, err = b.runOut(a, base.Cwd, nil, args...)    return ofile, output, err}

-toolexec 'cmd args'  a program to use to invoke toolchain programs like vet and asm.  For example, instead of running asm, the go command will run  'cmd args /path/to/asm <arguments for asm>'.

/home/atom/go/bin/garble /usr/local/go/pkg/tool/linux_amd64/compile -o $WORK/b016/_pkg_.a -trimpath "/usr/local/go/src/sync=>sync;$WORK/b016=>" -p sync -std -buildid FRNt7EHDh77qHujLKnmK/FRNt7EHDh77qHujLKnmK -goversion go1.16.4 -D "" -importcfg $WORK/b016/importcfg -pack -c=4 /usr/local/go/src/sync/cond.go /usr/local/go/src/sync/map.go /usr/local/go/src/sync/mutex.go /usr/local/go/src/sync/once.go /usr/local/go/src/sync/pool.go /usr/local/go/src/sync/poolqueue.go /usr/local/go/src/sync/runtime.go /usr/local/go/src/sync/runtime2.go /usr/local/go/src/sync/rwmutex.go /usr/local/go/src/sync/waitgroup.go

// listedPackage contains the 'go list -json -export' fields obtained by the// root process, shared with all garble sub-processes via a file.type listedPackage struct {    Name       string    ImportPath string    ForTest    string    Export     string    BuildID    string    Deps       []string    ImportMap  map[string]string    Standard   bool
    Dir     string    GoFiles []string
    // The fields below are not part of 'go list', but are still reused    // between garble processes. Use "Garble" as a prefix to ensure no    // collisions with the JSON fields from 'go list'.
    GarbleActionID []byte
    Private bool}
func setListedPackages(patterns []string) error {  args := []string{"list", "-json", "-deps", "-export", "-trimpath"}  args = append(args, cache.BuildFlags...)  args = append(args, patterns...)  cmd := exec.Command("go", args...)  ...  cache.ListedPackages = make(map[string]*listedPackage)  for ...{    var pkg listedPackage    ...    cache.ListedPackages[pkg.ImportPath] = &pkg    ...  }}

/home/atom/go/bin/garble /usr/local/go/pkg/tool/linux_amd64/compile -o $WORK/b016/_pkg_.a -trimpath "/usr/local/go/src/sync=>sync;$WORK/b016=>" -p sync -std -buildid FRNt7EHDh77qHujLKnmK/FRNt7EHDh77qHujLKnmK -goversion go1.16.4 -D "" -importcfg $WORK/b016/importcfg -pack -c=4 /usr/local/go/src/sync/cond.go /usr/local/go/src/sync/map.go /usr/local/go/src/sync/mutex.go /usr/local/go/src/sync/once.go /usr/local/go/src/sync/pool.go /usr/local/go/src/sync/poolqueue.go /usr/local/go/src/sync/runtime.go /usr/local/go/src/sync/runtime2.go /usr/local/go/src/sync/rwmutex.go /usr/local/go/src/sync/waitgroup.go

var files []*ast.Filefor _, path := range paths {  file, err := parser.ParseFile(fset, path, nil, parser.ParseComments)  if err != nil {    return nil, err  }  files = append(files, file)}

if fnType.Pkg().Path() == "reflect" && (fnType.Name() == "TypeOf" || fnType.Name() == "ValueOf") {  for _, arg := range call.Args {    argType := tf.info.TypeOf(arg)    tf.recordIgnore(argType, tf.pkg.Path())  }}

// ignoreObjects records all the objects we cannot obfuscate. An object// is any named entity, such as a declared variable or type.//// So far, this map records:////  * Types which are used for reflection; see recordReflectArgs.//  * Identifiers used in constant expressions; see RecordUsedAsConstants.//  * Identifiers used in go:linkname directives; see handleDirectives.//  * Types or variables from external packages which were not//    obfuscated, for caching reasons; see transformGo.ignoreObjects map[types.Object]bool

// RecordUsedAsConstants records identifieres used in constant expressions.func RecordUsedAsConstants(node ast.Node, info *types.Info, ignoreObj map[types.Object]bool) {    visit := func(node ast.Node) bool {        ident, ok := node.(*ast.Ident)        if !ok {            return true        }
        // Only record *types.Const objects.        // Other objects, such as builtins or type names,        // must not be recorded as they would be false positives.        obj := info.ObjectOf(ident)        if _, ok := obj.(*types.Const); ok {            ignoreObj[obj] = true        }
        return true    }
    switch x := node.(type) {    ...    // in a const declaration all values must be constant representable    case *ast.GenDecl:        if x.Tok != token.CONST {            break        }        for _, spec := range x.Specs {            spec := spec.(*ast.ValueSpec)
            for _, val := range spec.Values {                ast.Inspect(val, visit)            }        }    }}

package obfuscate
const (    H2 string = "a"    H4 string = "a" + H2    H3 int    = 123    H5 string = "a")

// transformGo obfuscates the provided Go syntax file.func (tf *transformer) transformGo(file *ast.File) *ast.File {    if opts.GarbleLiterals {        file = literals.Obfuscate(file, tf.info, fset, tf.ignoreObjects)    }
    pre := func(cursor *astutil.Cursor) bool {...}    post := func(cursor *astutil.Cursor) bool {...}
    return astutil.Apply(file, pre, post).(*ast.File)}