Function parse

pkg/pe/parser.go:251–405

(path string, data []byte, options ...Option)

}

func parse(path string, data []byte, options ...Option) (*PE, error) {
	var opts opts
	for _, opt := range options {
		opt(&opts)
	}
	if opts.isImageExcluded(path) {
		return nil, nil
	}
	var pe *peparser.File
	var err error
	if data == nil {
		pe, err = peparser.New(path, newParserOpts(opts))
	} else {
		pe, err = peparser.NewBytes(data, newParserOpts(opts))
	}
	if err != nil {
		return nil, err
	}
	defer pe.Close()

	// parse the DOS header
	err = pe.ParseDOSHeader()
	if err != nil {
		return nil, err
	}

	// parse the NT header
	err = pe.ParseNTHeader()
	if err != nil {
		return nil, err
	}

	timestamp := pe.NtHeader.FileHeader.TimeDateStamp
	linkTime := time.Date(1970, 1, 1, 0, 0, 0, 0, time.UTC).Add(time.Second * time.Duration(timestamp))
	p := &PE{
		NumberOfSections: pe.NtHeader.FileHeader.NumberOfSections,
		LinkTime:         linkTime,
		Symbols:          make([]string, 0),
		Imports:          make([]string, 0),
		Sections:         make([]Sec, 0),
		Exports:          make(map[uint32]string, 0),
		VersionResources: make(map[string]string),
		Is64:             pe.Is64,
		filename:         path,
		dosHeader:        pe.DOSHeader,
		ntHeader:         pe.NtHeader,
		sectionHeaders:   make([]peparser.ImageSectionHeader, 0),
	}

	switch pe.Is64 {
	case true:
		oh64 := pe.NtHeader.OptionalHeader.(peparser.ImageOptionalHeader64)
		p.ImageBase = format.UintToHex(oh64.ImageBase)
		p.EntryPoint = format.UintToHex(uint64(oh64.AddressOfEntryPoint))
	case false:
		oh32 := pe.NtHeader.OptionalHeader.(peparser.ImageOptionalHeader32)
		p.ImageBase = format.UintToHex(uint64(oh32.ImageBase))
		p.EntryPoint = format.UintToHex(uint64(oh32.AddressOfEntryPoint))