1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
|
// Copyright 2018 syzkaller project authors. All rights reserved.
// Use of this source code is governed by Apache 2 LICENSE that can be found in the LICENSE file.
//go:build !codeanalysis
// syz-trace2syz converts strace traces to syzkaller programs.
//
// Simple usage:
//
// strace -o trace -a 1 -s 65500 -v -xx -f -Xraw ./a.out
// syz-trace2syz -file trace
//
// Intended for seed selection or debugging
package main
import (
"flag"
"os"
"path/filepath"
"strconv"
"github.com/google/syzkaller/pkg/db"
"github.com/google/syzkaller/pkg/log"
"github.com/google/syzkaller/pkg/osutil"
"github.com/google/syzkaller/prog"
_ "github.com/google/syzkaller/sys"
"github.com/google/syzkaller/sys/targets"
"github.com/google/syzkaller/tools/syz-trace2syz/proggen"
)
var (
flagFile = flag.String("file", "", "file to parse")
flagDir = flag.String("dir", "", "directory to parse")
flagDeserialize = flag.String("deserialize", "", "(Optional) directory to store deserialized programs")
)
const (
goos = targets.Linux // Target OS
arch = targets.AMD64 // Target architecture
)
func main() {
flag.Parse()
target := initializeTarget(goos, arch)
progs := parseTraces(target)
log.Logf(0, "successfully converted traces; generating corpus.db")
pack(progs)
}
func initializeTarget(os, arch string) *prog.Target {
target, err := prog.GetTarget(os, arch)
if err != nil {
log.Fatalf("failed to load target: %s", err)
}
target.ConstMap = make(map[string]uint64)
for _, c := range target.Consts {
target.ConstMap[c.Name] = c.Value
}
return target
}
func parseTraces(target *prog.Target) []*prog.Prog {
var ret []*prog.Prog
var names []string
if *flagFile != "" {
names = append(names, *flagFile)
} else if *flagDir != "" {
names = getTraceFiles(*flagDir)
} else {
log.Fatalf("-file or -dir must be specified")
}
deserializeDir := *flagDeserialize
totalFiles := len(names)
log.Logf(0, "parsing %v traces", totalFiles)
for i, file := range names {
log.Logf(1, "parsing file %v/%v: %v", i+1, totalFiles, filepath.Base(names[i]))
progs, err := proggen.ParseFile(file, target)
if err != nil {
log.Fatalf("%v", err)
}
ret = append(ret, progs...)
if deserializeDir != "" {
for i, p := range progs {
progName := filepath.Join(deserializeDir, filepath.Base(file)+strconv.Itoa(i))
if err := osutil.WriteFile(progName, p.Serialize()); err != nil {
log.Fatalf("failed to output file: %v", err)
}
}
}
}
return ret
}
func getTraceFiles(dir string) []string {
infos, err := os.ReadDir(dir)
if err != nil {
log.Fatalf("%s", err)
}
var names []string
for _, info := range infos {
name := filepath.Join(dir, info.Name())
names = append(names, name)
}
return names
}
func pack(progs []*prog.Prog) {
var records []db.Record
for _, prog := range progs {
records = append(records, db.Record{Val: prog.Serialize()})
}
if err := db.Create("corpus.db", 0, records); err != nil {
log.Fatalf("%v", err)
}
log.Logf(0, "finished!")
}
|
