syzkaller: github.com/google/syzkaller/prog Index | Files | Directories

package prog

import "github.com/google/syzkaller/prog"

Index

Package Files

alloc.go analysis.go any.go checksum.go clone.go decodeexec.go encoding.go encodingexec.go generation.go hints.go little_endian.go meta.go minimization.go mutation.go parse.go prio.go prog.go rand.go resources.go rotation.go size.go target.go test_util.go types.go validation.go

Constants

const (
    ExecArgCsumChunkData = uint64(iota)
    ExecArgCsumChunkConst
)
const (
    ExecBufferSize = 4 << 20 // keep in sync with kMaxInput in executor.cc
    ExecNoCopyout  = ^uint64(0)
)
const (
    // "Recommended" number of calls in programs that we try to aim at during fuzzing.
    RecommendedCalls = 20
    // "Recommended" max number of calls in programs.
    // If we receive longer programs from hub/corpus we discard them.
    MaxCalls = 40
)
const (
    // Special reference to the outer struct used in len targets.
    ParentRef = "parent"
    // Special reference directly to syscall arguments used in len targets.
    SyscallRef = "syscall"
)
const (
    ExecArgCsumInet = uint64(iota)
)
const MaxArgs = 9

MaxArgs is maximum number of syscall arguments. Executor also knows about this value.

const (
    MaxPids = 32
)

Variables

var (
    GitRevision     string // emitted by Makefile, may contain + at the end
    GitRevisionBase string // without +

    GitRevisionDate time.Time // parsed from gitRevisionDate
)
var HostEndian = binary.LittleEndian

func CallSet Uses

func CallSet(data []byte) (map[string]struct{}, int, error)

CallSet returns a set of all calls in the program. It does very conservative parsing and is intended to parse past/future serialization formats.

func CppName Uses

func CppName(name string) string

CppName transforms PascalStyleNames to cpp_style_names.

func Debug Uses

func Debug()

func DecodeFallbackSignal Uses

func DecodeFallbackSignal(s uint32) (callID, errno int)

func EncodeData Uses

func EncodeData(buf *bytes.Buffer, data []byte, readable bool)

func ForeachArg Uses

func ForeachArg(c *Call, f func(Arg, *ArgCtx))

func ForeachCallType Uses

func ForeachCallType(meta *Syscall, f func(t Type, ctx TypeCtx))

func ForeachSubArg Uses

func ForeachSubArg(arg Arg, f func(Arg, *ArgCtx))

func ForeachType Uses

func ForeachType(syscalls []*Syscall, f func(t Type, ctx TypeCtx))

func ForeachTypePost Uses

func ForeachTypePost(syscalls []*Syscall, f func(t Type, ctx TypeCtx))

func IsPad Uses

func IsPad(t Type) bool

func RegisterTarget Uses

func RegisterTarget(target *Target, types []Type, initArch func(target *Target))

func RequiredFeatures Uses

func RequiredFeatures(p *Prog) (bitmasks, csums bool)
func RestoreLinks(syscalls []*Syscall, resources []*ResourceDesc, types []Type)

func TestDeserializeHelper Uses

func TestDeserializeHelper(t *testing.T, OS, arch string, transform func(*Target, *Prog), tests []DeserializeTest)

type Arg Uses

type Arg interface {
    Type() Type
    Dir() Dir
    Size() uint64
    // contains filtered or unexported methods
}

func InnerArg Uses

func InnerArg(arg Arg) Arg

Returns inner arg for pointer args.

type ArgCommon Uses

type ArgCommon struct {
    // contains filtered or unexported fields
}

func (*ArgCommon) Dir Uses

func (arg *ArgCommon) Dir() Dir

func (ArgCommon) Type Uses

func (arg ArgCommon) Type() Type

type ArgCtx Uses

type ArgCtx struct {
    Parent *[]Arg      // GroupArg.Inner (for structs) or Call.Args containing this arg.
    Fields []Field     // Fields of the parent struct/syscall.
    Base   *PointerArg // Pointer to the base of the heap object containing this arg.
    Offset uint64      // Offset of this arg from the base.
    Stop   bool        // If set by the callback, subargs of this arg are not visited.
}

type ArrayKind Uses

type ArrayKind int
const (
    ArrayRandLen ArrayKind = iota
    ArrayRangeLen
)

type ArrayType Uses

type ArrayType struct {
    TypeCommon
    Elem       Type
    Kind       ArrayKind
    RangeBegin uint64
    RangeEnd   uint64
}

func (*ArrayType) DefaultArg Uses

func (t *ArrayType) DefaultArg(dir Dir) Arg

func (*ArrayType) String Uses

func (t *ArrayType) String() string

type BinaryFormat Uses

type BinaryFormat int
const (
    FormatNative BinaryFormat = iota
    FormatBigEndian
    FormatStrDec
    FormatStrHex
    FormatStrOct
)

type BufferKind Uses

type BufferKind int
const (
    BufferBlobRand BufferKind = iota
    BufferBlobRange
    BufferString
    BufferFilename
    BufferText
)

type BufferType Uses

type BufferType struct {
    TypeCommon
    Kind       BufferKind
    RangeBegin uint64   // for BufferBlobRange kind
    RangeEnd   uint64   // for BufferBlobRange kind
    Text       TextKind // for BufferText
    SubKind    string
    Values     []string // possible values for BufferString kind
    NoZ        bool     // non-zero terminated BufferString/BufferFilename
}

func (*BufferType) DefaultArg Uses

func (t *BufferType) DefaultArg(dir Dir) Arg

func (*BufferType) String Uses

func (t *BufferType) String() string

type Builder Uses

type Builder struct {
    // contains filtered or unexported fields
}

func MakeProgGen Uses

func MakeProgGen(target *Target) *Builder

func (*Builder) Allocate Uses

func (pg *Builder) Allocate(size, alignment uint64) uint64

func (*Builder) AllocateVMA Uses

func (pg *Builder) AllocateVMA(npages uint64) uint64

func (*Builder) Append Uses

func (pg *Builder) Append(c *Call) error

func (*Builder) Finalize Uses

func (pg *Builder) Finalize() (*Prog, error)

type Call Uses

type Call struct {
    Meta    *Syscall
    Args    []Arg
    Ret     *ResultArg
    Comment string
}

type CallFlags Uses

type CallFlags int
const (
    CallExecuted CallFlags = 1 << iota // was started at all
    CallFinished                       // finished executing (rather than blocked forever)
    CallBlocked                        // finished but blocked during execution
)

type CallInfo Uses

type CallInfo struct {
    Flags  CallFlags
    Errno  int
    Signal []uint32
}

type ChoiceTable Uses

type ChoiceTable struct {
    // contains filtered or unexported fields
}

ChooseTable allows to do a weighted choice of a syscall for a given syscall based on call-to-call priorities and a set of enabled syscalls.

func (*ChoiceTable) Enabled Uses

func (ct *ChoiceTable) Enabled(call int) bool

type CompMap Uses

type CompMap map[uint64]map[uint64]bool

Example: for comparisons {(op1, op2), (op1, op3), (op1, op4), (op2, op1)} this map will store the following: m = {

op1: {map[op2]: true, map[op3]: true, map[op4]: true},
op2: {map[op1]: true}

}.

func (CompMap) AddComp Uses

func (m CompMap) AddComp(arg1, arg2 uint64)

func (CompMap) String Uses

func (m CompMap) String() string

type ConstArg Uses

type ConstArg struct {
    ArgCommon
    Val uint64
}

Used for ConstType, IntType, FlagsType, LenType, ProcType and CsumType.

func MakeConstArg Uses

func MakeConstArg(t Type, dir Dir, v uint64) *ConstArg

func (*ConstArg) Size Uses

func (arg *ConstArg) Size() uint64

func (*ConstArg) Value Uses

func (arg *ConstArg) Value() (uint64, uint64)

Value returns value and pid stride.

type ConstType Uses

type ConstType struct {
    IntTypeCommon
    Val   uint64
    IsPad bool
}

func (*ConstType) DefaultArg Uses

func (t *ConstType) DefaultArg(dir Dir) Arg

func (*ConstType) String Uses

func (t *ConstType) String() string

type ConstValue Uses

type ConstValue struct {
    Name  string
    Value uint64
}

type CsumChunk Uses

type CsumChunk struct {
    Kind  CsumChunkKind
    Arg   Arg    // for CsumChunkArg
    Value uint64 // for CsumChunkConst
    Size  uint64 // for CsumChunkConst
}

type CsumChunkKind Uses

type CsumChunkKind int
const (
    CsumChunkArg CsumChunkKind = iota
    CsumChunkConst
)

type CsumInfo Uses

type CsumInfo struct {
    Kind   CsumKind
    Chunks []CsumChunk
}

type CsumKind Uses

type CsumKind int
const (
    CsumInet CsumKind = iota
    CsumPseudo
)

type CsumType Uses

type CsumType struct {
    IntTypeCommon
    Kind     CsumKind
    Buf      string
    Protocol uint64 // for CsumPseudo
}

func (*CsumType) DefaultArg Uses

func (t *CsumType) DefaultArg(dir Dir) Arg

func (*CsumType) String Uses

func (t *CsumType) String() string

type DataArg Uses

type DataArg struct {
    ArgCommon
    // contains filtered or unexported fields
}

Used for BufferType.

func MakeDataArg Uses

func MakeDataArg(t Type, dir Dir, data []byte) *DataArg

func MakeOutDataArg Uses

func MakeOutDataArg(t Type, dir Dir, size uint64) *DataArg

func (*DataArg) Data Uses

func (arg *DataArg) Data() []byte

func (*DataArg) SetData Uses

func (arg *DataArg) SetData(data []byte)

func (*DataArg) Size Uses

func (arg *DataArg) Size() uint64

type DeserializeMode Uses

type DeserializeMode int
const (
    Strict    DeserializeMode = iota
    NonStrict DeserializeMode = iota
)

type DeserializeTest Uses

type DeserializeTest struct {
    In        string
    Out       string // if not set, equals to In
    Err       string
    StrictErr string // if not set, equals to Err
}

type Dir Uses

type Dir uint8
const (
    DirIn Dir = iota
    DirOut
    DirInOut
)

func (Dir) String Uses

func (dir Dir) String() string

type ExecArg Uses

type ExecArg interface{} // one of ExecArg*

type ExecArgConst Uses

type ExecArgConst struct {
    Size           uint64
    Format         BinaryFormat
    Value          uint64
    BitfieldOffset uint64
    BitfieldLength uint64
    PidStride      uint64
}

type ExecArgCsum Uses

type ExecArgCsum struct {
    Size   uint64
    Kind   uint64
    Chunks []ExecCsumChunk
}

type ExecArgData Uses

type ExecArgData struct {
    Data     []byte
    Readable bool
}

type ExecArgResult Uses

type ExecArgResult struct {
    Size    uint64
    Format  BinaryFormat
    Index   uint64
    DivOp   uint64
    AddOp   uint64
    Default uint64
}

type ExecCall Uses

type ExecCall struct {
    Meta    *Syscall
    Index   uint64
    Args    []ExecArg
    Copyin  []ExecCopyin
    Copyout []ExecCopyout
}

type ExecCopyin Uses

type ExecCopyin struct {
    Addr uint64
    Arg  ExecArg
}

type ExecCopyout Uses

type ExecCopyout struct {
    Index uint64
    Addr  uint64
    Size  uint64
}

type ExecCsumChunk Uses

type ExecCsumChunk struct {
    Kind  uint64
    Value uint64
    Size  uint64
}

type ExecProg Uses

type ExecProg struct {
    Calls []ExecCall
    Vars  []uint64
}

type Field Uses

type Field struct {
    Name string
    Type
}

type FlagsType Uses

type FlagsType struct {
    IntTypeCommon
    Vals    []uint64 // compiler ensures that it's not empty
    BitMask bool
}

func (*FlagsType) DefaultArg Uses

func (t *FlagsType) DefaultArg(dir Dir) Arg

type Gen Uses

type Gen struct {
    // contains filtered or unexported fields
}

func (*Gen) Alloc Uses

func (g *Gen) Alloc(ptrType Type, dir Dir, data Arg) (Arg, []*Call)

func (*Gen) GenerateArg Uses

func (g *Gen) GenerateArg(typ Type, dir Dir, pcalls *[]*Call) Arg

func (*Gen) GenerateSpecialArg Uses

func (g *Gen) GenerateSpecialArg(typ Type, dir Dir, pcalls *[]*Call) Arg

func (*Gen) MutateArg Uses

func (g *Gen) MutateArg(arg0 Arg) (calls []*Call)

func (*Gen) NOutOf Uses

func (g *Gen) NOutOf(n, outOf int) bool

func (*Gen) Rand Uses

func (g *Gen) Rand() *rand.Rand

func (*Gen) Target Uses

func (g *Gen) Target() *Target

type GroupArg Uses

type GroupArg struct {
    ArgCommon
    Inner []Arg
}

Used for StructType and ArrayType. Logical group of args (struct or array).

func MakeGroupArg Uses

func MakeGroupArg(t Type, dir Dir, inner []Arg) *GroupArg

func (*GroupArg) Size Uses

func (arg *GroupArg) Size() uint64

type IntKind Uses

type IntKind int
const (
    IntPlain IntKind = iota
    IntRange
)

type IntType Uses

type IntType struct {
    IntTypeCommon
    Kind       IntKind
    RangeBegin uint64
    RangeEnd   uint64
    Align      uint64
}

func (*IntType) DefaultArg Uses

func (t *IntType) DefaultArg(dir Dir) Arg

type IntTypeCommon Uses

type IntTypeCommon struct {
    TypeCommon
    ArgFormat       BinaryFormat
    BitfieldOff     uint64
    BitfieldLen     uint64
    BitfieldUnit    uint64
    BitfieldUnitOff uint64
}

func (*IntTypeCommon) BitfieldLength Uses

func (t *IntTypeCommon) BitfieldLength() uint64

func (*IntTypeCommon) BitfieldOffset Uses

func (t *IntTypeCommon) BitfieldOffset() uint64

func (*IntTypeCommon) Format Uses

func (t *IntTypeCommon) Format() BinaryFormat

func (*IntTypeCommon) IsBitfield Uses

func (t *IntTypeCommon) IsBitfield() bool

func (*IntTypeCommon) String Uses

func (t *IntTypeCommon) String() string

func (*IntTypeCommon) TypeBitSize Uses

func (t *IntTypeCommon) TypeBitSize() uint64

Returns the size in bits for integers in binary format or 64 for string-formatted integers. The return value is used in computing limits and truncating other values.

func (*IntTypeCommon) UnitOffset Uses

func (t *IntTypeCommon) UnitOffset() uint64

func (*IntTypeCommon) UnitSize Uses

func (t *IntTypeCommon) UnitSize() uint64

type LenType Uses

type LenType struct {
    IntTypeCommon
    BitSize uint64 // want size in multiple of bits instead of array size
    Offset  bool   // offset from the beginning of the parent struct or base object
    Path    []string
}

func (*LenType) DefaultArg Uses

func (t *LenType) DefaultArg(dir Dir) Arg

type LogEntry Uses

type LogEntry struct {
    P         *Prog
    Proc      int  // index of parallel proc
    Start     int  // start offset in log
    End       int  // end offset in log
    Fault     bool // program was executed with fault injection in FaultCall/FaultNth
    FaultCall int
    FaultNth  int
}

LogEntry describes one program in execution log.

type PointerArg Uses

type PointerArg struct {
    ArgCommon
    Address uint64
    VmaSize uint64 // size of the referenced region for vma args
    Res     Arg    // pointee (nil for vma)
}

Used for PtrType and VmaType.

func MakePointerArg Uses

func MakePointerArg(t Type, dir Dir, addr uint64, data Arg) *PointerArg

func MakeSpecialPointerArg Uses

func MakeSpecialPointerArg(t Type, dir Dir, index uint64) *PointerArg

func MakeVmaPointerArg Uses

func MakeVmaPointerArg(t Type, dir Dir, addr, size uint64) *PointerArg

func (*PointerArg) IsSpecial Uses

func (arg *PointerArg) IsSpecial() bool

func (*PointerArg) Size Uses

func (arg *PointerArg) Size() uint64

type ProcType Uses

type ProcType struct {
    IntTypeCommon
    ValuesStart   uint64
    ValuesPerProc uint64
}

func (*ProcType) DefaultArg Uses

func (t *ProcType) DefaultArg(dir Dir) Arg

type Prog Uses

type Prog struct {
    Target   *Target
    Calls    []*Call
    Comments []string
}

func Minimize Uses

func Minimize(p0 *Prog, callIndex0 int, crash bool, pred0 func(*Prog, int) bool) (*Prog, int)

Minimize minimizes program p into an equivalent program using the equivalence predicate pred. It iteratively generates simpler programs and asks pred whether it is equal to the original program or not. If it is equivalent then the simplification attempt is committed and the process continues.

func (*Prog) Clone Uses

func (p *Prog) Clone() *Prog

func (*Prog) FallbackSignal Uses

func (p *Prog) FallbackSignal(info []CallInfo)

func (*Prog) Mutate Uses

func (p *Prog) Mutate(rs rand.Source, ncalls int, ct *ChoiceTable, corpus []*Prog)

Mutate program p.

p: The program to mutate. rs: Random source. ncalls: The allowed maximum calls in mutated program. ct: ChoiceTable for syscalls. corpus: The entire corpus, including original program p.

func (*Prog) MutateWithHints Uses

func (p *Prog) MutateWithHints(callIndex int, comps CompMap, exec func(p *Prog))

Mutates the program using the comparison operands stored in compMaps. For each of the mutants executes the exec callback.

func (*Prog) Serialize Uses

func (p *Prog) Serialize() []byte

func (*Prog) SerializeForExec Uses

func (p *Prog) SerializeForExec(buffer []byte) (int, error)

SerializeForExec serializes program p for execution by process pid into the provided buffer. Returns number of bytes written to the buffer. If the provided buffer is too small for the program an error is returned.

func (*Prog) SerializeVerbose Uses

func (p *Prog) SerializeVerbose() []byte

func (*Prog) String Uses

func (p *Prog) String() string

String generates a very compact program description (mostly for debug output).

type PtrType Uses

type PtrType struct {
    TypeCommon
    Elem    Type
    ElemDir Dir
}

func (*PtrType) DefaultArg Uses

func (t *PtrType) DefaultArg(dir Dir) Arg

func (*PtrType) String Uses

func (t *PtrType) String() string

type Ref Uses

type Ref uint32

func (Ref) Alignment Uses

func (ti Ref) Alignment() uint64

func (Ref) BitfieldLength Uses

func (ti Ref) BitfieldLength() uint64

func (Ref) BitfieldOffset Uses

func (ti Ref) BitfieldOffset() uint64

func (Ref) Clone Uses

func (ti Ref) Clone() Type

func (Ref) DefaultArg Uses

func (ti Ref) DefaultArg(dir Dir) Arg

func (Ref) Format Uses

func (ti Ref) Format() BinaryFormat

func (Ref) IsBitfield Uses

func (ti Ref) IsBitfield() bool

func (Ref) Name Uses

func (ti Ref) Name() string

func (Ref) Optional Uses

func (ti Ref) Optional() bool

func (Ref) Size Uses

func (ti Ref) Size() uint64

func (Ref) String Uses

func (ti Ref) String() string

func (Ref) TemplateName Uses

func (ti Ref) TemplateName() string

func (Ref) TypeBitSize Uses

func (ti Ref) TypeBitSize() uint64

func (Ref) UnitOffset Uses

func (ti Ref) UnitOffset() uint64

func (Ref) UnitSize Uses

func (ti Ref) UnitSize() uint64

func (Ref) Varlen Uses

func (ti Ref) Varlen() bool

type ResourceCtor Uses

type ResourceCtor struct {
    Call    int // index in Target.Syscalls
    Precise bool
}

type ResourceDesc Uses

type ResourceDesc struct {
    Name   string
    Kind   []string
    Values []uint64
    Ctors  []ResourceCtor
}

type ResourceType Uses

type ResourceType struct {
    TypeCommon
    ArgFormat BinaryFormat
    Desc      *ResourceDesc
}

func (*ResourceType) Default Uses

func (t *ResourceType) Default() uint64

func (*ResourceType) DefaultArg Uses

func (t *ResourceType) DefaultArg(dir Dir) Arg

func (*ResourceType) Format Uses

func (t *ResourceType) Format() BinaryFormat

func (*ResourceType) SpecialValues Uses

func (t *ResourceType) SpecialValues() []uint64

func (*ResourceType) String Uses

func (t *ResourceType) String() string

type ResultArg Uses

type ResultArg struct {
    ArgCommon
    Res   *ResultArg // reference to arg which we use
    OpDiv uint64     // divide result (executed before OpAdd)
    OpAdd uint64     // add to result
    Val   uint64     // value used if Res is nil
    // contains filtered or unexported fields
}

Used for ResourceType. This is the only argument that can be used as syscall return value. Either holds constant value or reference another ResultArg.

func MakeResultArg Uses

func MakeResultArg(t Type, dir Dir, r *ResultArg, v uint64) *ResultArg

func MakeReturnArg Uses

func MakeReturnArg(t Type) *ResultArg

func (*ResultArg) Size Uses

func (arg *ResultArg) Size() uint64

type Rotator Uses

type Rotator struct {
    // contains filtered or unexported fields
}

Rotator selects a random subset of syscalls for corpus rotation.

func MakeRotator Uses

func MakeRotator(target *Target, calls map[*Syscall]bool, rnd *rand.Rand) *Rotator

func (*Rotator) Select Uses

func (r *Rotator) Select() map[*Syscall]bool

type StructType Uses

type StructType struct {
    TypeCommon
    Fields    []Field
    AlignAttr uint64
}

func (*StructType) DefaultArg Uses

func (t *StructType) DefaultArg(dir Dir) Arg

func (*StructType) String Uses

func (t *StructType) String() string

type Syscall Uses

type Syscall struct {
    ID          int
    NR          uint64 // kernel syscall number
    Name        string
    CallName    string
    MissingArgs int // number of trailing args that should be zero-filled
    Args        []Field
    Ret         Type
    Attrs       SyscallAttrs
    // contains filtered or unexported fields
}

type SyscallAttrs Uses

type SyscallAttrs struct {
    Disabled      bool
    Timeout       uint64
    ProgTimeout   uint64
    IgnoreReturn  bool
    BreaksReturns bool
}

SyscallAttrs represents call attributes in syzlang.

This structure is the source of truth for the all other parts of the system. pkg/compiler uses this structure to parse descriptions. syz-sysgen uses this structure to generate code for executor.

Only bool's and uint64's are currently supported.

See docs/syscall_descriptions_syntax.md for description of individual attributes.

type Target Uses

type Target struct {
    OS           string
    Arch         string
    Revision     string // unique hash representing revision of the descriptions
    PtrSize      uint64
    PageSize     uint64
    NumPages     uint64
    DataOffset   uint64
    LittleEndian bool

    Syscalls  []*Syscall
    Resources []*ResourceDesc
    Consts    []ConstValue

    // MakeDataMmap creates calls that mmaps target data memory range.
    MakeDataMmap func() []*Call

    // Neutralize neutralizes harmful calls by transforming them into non-harmful ones
    // (e.g. an ioctl that turns off console output is turned into ioctl that turns on output).
    Neutralize func(c *Call)

    // AnnotateCall annotates a syscall invocation in C reproducers.
    // The returned string will be placed inside a comment except for the
    // empty string which will omit the comment.
    AnnotateCall func(c ExecCall) string

    // SpecialTypes allows target to do custom generation/mutation for some struct's and union's.
    // Map key is struct/union name for which custom generation/mutation is required.
    // Map value is custom generation/mutation function that will be called
    // for the corresponding type. g is helper object that allows generate random numbers,
    // allocate memory, etc. typ is the struct/union type. old is the old value of the struct/union
    // for mutation, or nil for generation. The function returns a new value of the struct/union,
    // and optionally any calls that need to be inserted before the arg reference.
    SpecialTypes map[string]func(g *Gen, typ Type, dir Dir, old Arg) (Arg, []*Call)

    // Resources that play auxiliary role, but widely used throughout all syscalls (e.g. pid/uid).
    AuxResources map[string]bool

    // Additional special invalid pointer values besides NULL to use.
    SpecialPointers []uint64

    // Filled by prog package:
    SyscallMap map[string]*Syscall
    ConstMap   map[string]uint64
    // contains filtered or unexported fields
}

Target describes target OS/arch pair.

func AllTargets Uses

func AllTargets() []*Target

func GetTarget Uses

func GetTarget(OS, arch string) (*Target, error)

func InitTargetTest Uses

func InitTargetTest(t *testing.T, os, arch string) *Target

func (*Target) ArgContainsAny Uses

func (target *Target) ArgContainsAny(arg0 Arg) (res bool)

func (*Target) BuildChoiceTable Uses

func (target *Target) BuildChoiceTable(corpus []*Prog, enabled map[*Syscall]bool) *ChoiceTable

func (*Target) CalculatePriorities Uses

func (target *Target) CalculatePriorities(corpus []*Prog) [][]float32

func (*Target) CallContainsAny Uses

func (target *Target) CallContainsAny(c *Call) (res bool)

func (*Target) DataMmapProg Uses

func (target *Target) DataMmapProg() *Prog

DataMmapProg creates program that maps data segment. Also used for testing as the simplest program.

func (*Target) DefaultChoiceTable Uses

func (target *Target) DefaultChoiceTable() *ChoiceTable

func (*Target) Deserialize Uses

func (target *Target) Deserialize(data []byte, mode DeserializeMode) (*Prog, error)

func (*Target) DeserializeExec Uses

func (target *Target) DeserializeExec(exec []byte) (ExecProg, error)

func (*Target) Generate Uses

func (target *Target) Generate(rs rand.Source, ncalls int, ct *ChoiceTable) *Prog

Generate generates a random program with ncalls calls. ct contains a set of allowed syscalls, if nil all syscalls are used.

func (*Target) GenerateAllSyzProg Uses

func (target *Target) GenerateAllSyzProg(rs rand.Source) *Prog

GenerateAllSyzProg generates a program that contains all pseudo syz_ calls for testing.

func (*Target) GetConst Uses

func (target *Target) GetConst(name string) uint64

func (*Target) ParseLog Uses

func (target *Target) ParseLog(data []byte) []*LogEntry

func (*Target) PhysicalAddr Uses

func (target *Target) PhysicalAddr(arg *PointerArg) uint64

func (*Target) TransitivelyEnabledCalls Uses

func (target *Target) TransitivelyEnabledCalls(enabled map[*Syscall]bool) (map[*Syscall]bool, map[*Syscall]string)

type TextKind Uses

type TextKind int
const (
    TextTarget TextKind = iota
    TextX86Real
    TextX86bit16
    TextX86bit32
    TextX86bit64
    TextArm64
)

type Type Uses

type Type interface {
    String() string
    Name() string
    TemplateName() string // for template structs name without arguments
    Optional() bool
    Varlen() bool
    Size() uint64
    TypeBitSize() uint64
    Alignment() uint64
    Format() BinaryFormat
    BitfieldOffset() uint64
    BitfieldLength() uint64
    IsBitfield() bool
    // For most of the types UnitSize is equal to Size.
    // These are different only for all but last bitfield in the group,
    // where Size == 0 and UnitSize equals to the underlying bitfield type size.
    UnitSize() uint64
    UnitOffset() uint64

    DefaultArg(dir Dir) Arg
    // contains filtered or unexported methods
}

type TypeCommon Uses

type TypeCommon struct {
    TypeName string
    // Static size of the type, or 0 for variable size types and all but last bitfields in the group.
    TypeSize   uint64
    TypeAlign  uint64
    IsOptional bool
    IsVarlen   bool
    // contains filtered or unexported fields
}

func (*TypeCommon) Alignment Uses

func (t *TypeCommon) Alignment() uint64

func (*TypeCommon) BitfieldLength Uses

func (t *TypeCommon) BitfieldLength() uint64

func (*TypeCommon) BitfieldOffset Uses

func (t *TypeCommon) BitfieldOffset() uint64

func (*TypeCommon) Format Uses

func (t *TypeCommon) Format() BinaryFormat

func (*TypeCommon) IsBitfield Uses

func (t *TypeCommon) IsBitfield() bool

func (*TypeCommon) Name Uses

func (t *TypeCommon) Name() string

func (*TypeCommon) Optional Uses

func (t *TypeCommon) Optional() bool

func (*TypeCommon) Size Uses

func (t *TypeCommon) Size() uint64

func (*TypeCommon) TemplateName Uses

func (t *TypeCommon) TemplateName() string

func (*TypeCommon) TypeBitSize Uses

func (t *TypeCommon) TypeBitSize() uint64

func (*TypeCommon) UnitOffset Uses

func (t *TypeCommon) UnitOffset() uint64

func (*TypeCommon) UnitSize Uses

func (t *TypeCommon) UnitSize() uint64

func (*TypeCommon) Varlen Uses

func (t *TypeCommon) Varlen() bool

type TypeCtx Uses

type TypeCtx struct {
    Meta *Syscall
    Dir  Dir
    Ptr  *Type
}

type UnionArg Uses

type UnionArg struct {
    ArgCommon
    Option Arg
    Index  int // Index of the selected option in the union type.
}

Used for UnionType.

func MakeUnionArg Uses

func MakeUnionArg(t Type, dir Dir, opt Arg, index int) *UnionArg

func (*UnionArg) Size Uses

func (arg *UnionArg) Size() uint64

type UnionType Uses

type UnionType struct {
    TypeCommon
    Fields []Field
}

func (*UnionType) DefaultArg Uses

func (t *UnionType) DefaultArg(dir Dir) Arg

func (*UnionType) String Uses

func (t *UnionType) String() string

type VmaType Uses

type VmaType struct {
    TypeCommon
    RangeBegin uint64 // in pages
    RangeEnd   uint64
}

func (*VmaType) DefaultArg Uses

func (t *VmaType) DefaultArg(dir Dir) Arg

func (*VmaType) String Uses

func (t *VmaType) String() string

Directories

PathSynopsis
test

Package prog imports 18 packages (graph) and is imported by 85 packages. Updated 2020-08-05. Refresh now. Tools for package owners.