cli/q
1
0
Fork 0
Code Issues Pull requests Releases Activity

Improved Windows support

Browse source
This commit is contained in:
Eduard Urbach 2024-08-13 19:34:54 +02:00
parent 3dffa69f37
commit 33da0cc315
Signed by: eduard
GPG key ID: 49226B848C78F6C8
16 changed files with 142 additions and 57 deletions
Download patch file Download diff file Expand all files Collapse all files

8
src/os/linux/elf/Constants.go
View file

@ -1,5 +1,13 @@
package elf
const (
// Align decides the alignment of the sections and it must be a multiple of the page size.
Align = 0x1000
// The code offset is the offset of the executable machine code within the file.
CodeOffset = HeaderSize + ProgramHeaderSize*2
)
const (
LittleEndian = 1
TypeExecutable = 2

16
src/os/linux/elf/ELF.go
View file

@ -22,8 +22,8 @@ type ELF struct {
// New creates a new ELF binary.
func New(code []byte, data []byte) *ELF {
dataOffset := config.CodeOffset + int64(len(code))
dataPadding := common.Padding(dataOffset, config.Align)
dataOffset := CodeOffset + int64(len(code))
dataPadding := common.Padding(dataOffset, Align)
dataOffset += dataPadding
return &ELF{
@ -37,7 +37,7 @@ func New(code []byte, data []byte) *ELF {
Type: TypeExecutable,
Architecture: ArchitectureAMD64,
FileVersion: 1,
EntryPointInMemory: config.BaseAddress + config.CodeOffset,
EntryPointInMemory: config.BaseAddress + CodeOffset,
ProgramHeaderOffset: HeaderSize,
SectionHeaderOffset: 0,
Flags: 0,
@ -51,12 +51,12 @@ func New(code []byte, data []byte) *ELF {
CodeHeader: ProgramHeader{
Type: ProgramTypeLOAD,
Flags: ProgramFlagsExecutable | ProgramFlagsReadable,
Offset: config.CodeOffset,
VirtualAddress: config.BaseAddress + config.CodeOffset,
PhysicalAddress: config.BaseAddress + config.CodeOffset,
Offset: CodeOffset,
VirtualAddress: config.BaseAddress + CodeOffset,
PhysicalAddress: config.BaseAddress + CodeOffset,
SizeInFile: int64(len(code)),
SizeInMemory: int64(len(code)),
Align: config.Align,
Align: Align,
},
DataHeader: ProgramHeader{
Type: ProgramTypeLOAD,
@ -66,7 +66,7 @@ func New(code []byte, data []byte) *ELF {
PhysicalAddress: config.BaseAddress + dataOffset,
SizeInFile: int64(len(data)),
SizeInMemory: int64(len(data)),
Align: config.Align,
Align: Align,
},
CodePadding: nil,
Code: code,

8
src/os/mac/macho/Constants.go
View file

@ -1,5 +1,13 @@
package macho
const (
// Align decides the alignment of the sections and it must be a multiple of the page size.
Align = 0x1000
// The code offset is the offset of the executable machine code within the file.
CodeOffset = 32 + 0x48*3 + 184
)
type CPU uint32
const (

10
src/os/mac/macho/MachO.go
View file

@ -25,7 +25,7 @@ func New(code []byte, data []byte) *MachO {
MicroArchitecture: 3 | 0x80000000,
Type: TypeExecute,
NumCommands: 4,
SizeCommands: 0x48*3 + 184,
SizeCommands: 72*3 + 184,
Flags: FlagNoUndefs,
Reserved: 0,
},
@ -40,7 +40,7 @@ func (m *MachO) Write(writer io.Writer) {
binary.Write(writer, binary.LittleEndian, &Segment64{
LoadCommand: LcSegment64,
Length: 0x48,
Length: 72,
Name: [16]byte{'_', '_', 'P', 'A', 'G', 'E', 'Z', 'E', 'R', 'O'},
Address: 0,
SizeInMemory: config.BaseAddress,
@ -55,12 +55,12 @@ func (m *MachO) Write(writer io.Writer) {
codeStart := uint64(32 + m.Header.SizeCommands)
codeLength := uint64(len(m.Code))
codeEnd := codeStart + codeLength
dataPadding := common.Padding(codeEnd, config.Align)
dataPadding := common.Padding(codeEnd, Align)
dataStart := codeEnd + dataPadding
binary.Write(writer, binary.LittleEndian, &Segment64{
LoadCommand: LcSegment64,
Length: 0x48,
Length: 72,
Name: [16]byte{'_', '_', 'T', 'E', 'X', 'T'},
Address: config.BaseAddress + codeStart,
SizeInMemory: codeLength,
@ -74,7 +74,7 @@ func (m *MachO) Write(writer io.Writer) {
binary.Write(writer, binary.LittleEndian, &Segment64{
LoadCommand: LcSegment64,
Length: 0x48,
Length: 72,
Name: [16]byte{'_', '_', 'D', 'A', 'T', 'A'},
Address: config.BaseAddress + dataStart,
SizeInMemory: uint64(len(m.Data)),

8
src/os/windows/pe/Constants.go
View file

@ -1,5 +1,13 @@
package pe
const (
// Align decides the alignment of the sections.
Align = 0x200
// The code offset is the offset of the executable machine code within the file.
CodeOffset = Align
)
// CPU
const (
IMAGE_FILE_MACHINE_AMD64 = 0x8664

6
src/os/windows/pe/DOSHeader.go
View file

@ -1,9 +1,11 @@
package pe
const DOSHeaderSize = 64
// DOSHeader is at the beginning of each EXE file and nowadays just points
// to the NTHeader using an absolute file offset.
// to the PEHeader using an absolute file offset.
type DOSHeader struct {
Magic [4]byte
_ [56]byte
NTHeaderOffset uint32
PEHeaderOffset uint32
}

84
src/os/windows/pe/EXE.go
View file

@ -1,6 +1,7 @@
package pe
import (
"bytes"
"encoding/binary"
"io"
@ -8,53 +9,58 @@ import (
"git.akyoto.dev/cli/q/src/os/common"
)
const NumSections = 2
// EXE is the portable executable format used on Windows.
type EXE struct {
DOSHeader
NTHeader
PEHeader
OptionalHeader64
CodeHeader SectionHeader
Code []byte
Data []byte
Sections [NumSections]SectionHeader
CodePadding []byte
Code []byte
DataPadding []byte
Data []byte
}
// New creates a new EXE file.
func New(code []byte, data []byte) *EXE {
const codeStart = 0x170
const optHeaderSize = 0xF0
codeStart := uint32(DOSHeaderSize + PEHeaderSize + OptionalHeader64Size + SectionHeaderSize*NumSections)
codePadding := common.Padding(codeStart, Align)
codeStart += codePadding
codeSize := uint32(len(code))
headerSize := uint32(codeStart)
sectionAlign := uint32(0x10)
fileAlign := uint32(0x10)
imageSize := uint32(codeStart + len(code))
imageSize += common.Padding(imageSize, sectionAlign)
dataStart := codeStart + uint32(len(code))
dataPadding := common.Padding(dataStart, Align)
dataStart += dataPadding
imageSize := uint32(dataStart + uint32(len(data)))
imageSize += common.Padding(imageSize, Align)
return &EXE{
DOSHeader: DOSHeader{
Magic: [4]byte{'M', 'Z', 0, 0},
NTHeaderOffset: 0x40,
PEHeaderOffset: 0x40,
},
NTHeader: NTHeader{
PEHeader: PEHeader{
Signature: [4]byte{'P', 'E', 0, 0},
Machine: IMAGE_FILE_MACHINE_AMD64,
NumberOfSections: 1,
SizeOfOptionalHeader: optHeaderSize,
NumberOfSections: NumSections,
SizeOfOptionalHeader: OptionalHeader64Size,
Characteristics: IMAGE_FILE_EXECUTABLE_IMAGE | IMAGE_FILE_LARGE_ADDRESS_AWARE,
},
OptionalHeader64: OptionalHeader64{
Magic: 0x020B, // PE32+ executable
MajorLinkerVersion: 0x0E,
MinorLinkerVersion: 0x16,
SizeOfCode: codeSize,
SizeOfCode: uint32(len(code)),
AddressOfEntryPoint: codeStart,
ImageBase: config.BaseAddress,
SectionAlignment: sectionAlign, // power of 2, must be greater than or equal to FileAlignment
FileAlignment: fileAlign, // power of 2
SectionAlignment: Align, // power of 2, must be greater than or equal to FileAlignment
FileAlignment: Align, // power of 2
MajorOperatingSystemVersion: 0x06,
MajorSubsystemVersion: 0x06,
SizeOfImage: imageSize,
SizeOfHeaders: headerSize,
SizeOfHeaders: codeStart, // section bodies begin here
Subsystem: IMAGE_SUBSYSTEM_WINDOWS_GUI,
DllCharacteristics: IMAGE_DLLCHARACTERISTICS_HIGH_ENTROPY_VA | IMAGE_DLLCHARACTERISTICS_DYNAMIC_BASE | IMAGE_DLLCHARACTERISTICS_NX_COMPAT | IMAGE_DLLCHARACTERISTICS_TERMINAL_SERVER_AWARE,
SizeOfStackReserve: 0x100000,
@ -81,25 +87,39 @@ func New(code []byte, data []byte) *EXE {
{VirtualAddress: 0, Size: 0},
},
},
CodeHeader: SectionHeader{
Name: [8]byte{'.', 't', 'e', 'x', 't'},
VirtualSize: uint32(len(code)),
VirtualAddress: codeStart,
RawSize: uint32(len(code)), // must be a multiple of FileAlignment
RawAddress: codeStart, // must be a multiple of FileAlignment
Characteristics: IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ,
Sections: [NumSections]SectionHeader{
{
Name: [8]byte{'.', 'c', 'o', 'd', 'e'},
VirtualSize: uint32(len(code)),
VirtualAddress: codeStart,
RawSize: uint32(len(code)), // must be a multiple of FileAlignment
RawAddress: codeStart, // must be a multiple of FileAlignment
Characteristics: IMAGE_SCN_CNT_CODE | IMAGE_SCN_MEM_EXECUTE | IMAGE_SCN_MEM_READ,
},
{
Name: [8]byte{'.', 'd', 'a', 't', 'a'},
VirtualSize: uint32(len(data)),
VirtualAddress: dataStart,
RawSize: uint32(len(data)), // must be a multiple of FileAlignment
RawAddress: dataStart, // must be a multiple of FileAlignment
Characteristics: IMAGE_SCN_CNT_INITIALIZED_DATA | IMAGE_SCN_MEM_READ,
},
},
Code: code,
// Data: data,
CodePadding: bytes.Repeat([]byte{0}, int(codePadding)),
Code: code,
DataPadding: bytes.Repeat([]byte{0}, int(dataPadding)),
Data: data,
}
}
// Write writes the EXE file to the given writer.
func (pe *EXE) Write(writer io.Writer) {
binary.Write(writer, binary.LittleEndian, &pe.DOSHeader)
binary.Write(writer, binary.LittleEndian, &pe.NTHeader)
binary.Write(writer, binary.LittleEndian, &pe.PEHeader)
binary.Write(writer, binary.LittleEndian, &pe.OptionalHeader64)
binary.Write(writer, binary.LittleEndian, &pe.CodeHeader)
binary.Write(writer, binary.LittleEndian, &pe.Sections)
binary.Write(writer, binary.LittleEndian, &pe.CodePadding)
binary.Write(writer, binary.LittleEndian, &pe.Code)
// binary.Write(writer, binary.LittleEndian, &pe.Data)
binary.Write(writer, binary.LittleEndian, &pe.DataPadding)
binary.Write(writer, binary.LittleEndian, &pe.Data)
}

9
src/os/windows/pe/ImportDirectory.go Normal file
View file

@ -0,0 +1,9 @@
package pe
type ImportDirectory struct {
OriginalFirstThunk uint32
TimeDateStamp uint32
ForwarderChain uint32
Name uint32
FirstThunk uint32
}

2
src/os/windows/pe/OptionalHeader64.go
View file

@ -1,5 +1,7 @@
package pe
const OptionalHeader64Size = 240
type OptionalHeader64 struct {
Magic uint16
MajorLinkerVersion uint8

4
src/os/windows/pe/NTHeader.go → src/os/windows/pe/PEHeader.go
View file

@ -1,6 +1,8 @@
package pe
type NTHeader struct {
const PEHeaderSize = 24
type PEHeader struct {
Signature [4]byte
Machine uint16
NumberOfSections uint16

2
src/os/windows/pe/SectionHeader.go
View file

@ -1,5 +1,7 @@
package pe
const SectionHeaderSize = 40
type SectionHeader struct {
Name [8]byte
VirtualSize uint32