format pe gui on "nul"    

What is your exact 1.67 build?

;;; Source file names
filename equ "4k.exe"
stubname equ "stub.bin"

include "Macro\Struct.Inc"

;;; Some utility macros
struc reequ [value] {
common
  restore .
  . equ value
}

;;; Define BYTE/WORD/etc. macros to use struct definitions from SDK almost as-is
irp pair, BYTE db, WORD dw, DWORD dd, ULONGLONG dq {
  match c_type fasm_directive, pair \{
    macro c_type [name*] \\{
      _name equ name
      _value equ ?
      match .name[.count], name \\\{; handle array syntax
        _name reequ .name
        _value reequ .count dup ?
      \\\}
      match .name .value, _name _value \\\{ .name fasm_directive .value \\\}
      restore _name, _value
    \\}
  \}
}

struct IMAGE_FILE_HEADER
    WORD    Machine;
    WORD    NumberOfSections;
    DWORD   TimeDateStamp;
    DWORD   PointerToSymbolTable;
    DWORD   NumberOfSymbols;
    WORD    SizeOfOptionalHeader;
    WORD    Characteristics;
ends

struct IMAGE_OPTIONAL_HEADER
    WORD    Magic;
    BYTE    MajorLinkerVersion;
    BYTE    MinorLinkerVersion;
    DWORD   SizeOfCode;
    DWORD   SizeOfInitializedData;
    DWORD   SizeOfUninitializedData;
    DWORD   AddressOfEntryPoint;
    DWORD   BaseOfCode;
    DWORD   BaseOfData;
    DWORD   ImageBase;
    DWORD   SectionAlignment;
    DWORD   FileAlignment;
    WORD    MajorOperatingSystemVersion;
    WORD    MinorOperatingSystemVersion;
    WORD    MajorImageVersion;
    WORD    MinorImageVersion;
    WORD    MajorSubsystemVersion;
    WORD    MinorSubsystemVersion;
    DWORD   Win32VersionValue;
    DWORD   SizeOfImage;
    DWORD   SizeOfHeaders;
    DWORD   CheckSum;
    WORD    Subsystem;
    WORD    DllCharacteristics;
    DWORD   SizeOfStackReserve;
    DWORD   SizeOfStackCommit;
    DWORD   SizeOfHeapReserve;
    DWORD   SizeOfHeapCommit;
    DWORD   LoaderFlags;
    DWORD   NumberOfRvaAndSizes;
;    IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
ends

struct IMAGE_OPTIONAL_HEADER64
    WORD        Magic;
    BYTE        MajorLinkerVersion;
    BYTE        MinorLinkerVersion;
    DWORD       SizeOfCode;
    DWORD       SizeOfInitializedData;
    DWORD       SizeOfUninitializedData;
    DWORD       AddressOfEntryPoint;
    DWORD       BaseOfCode;
    ULONGLONG   ImageBase;
    DWORD       SectionAlignment;
    DWORD       FileAlignment;
    WORD        MajorOperatingSystemVersion;
    WORD        MinorOperatingSystemVersion;
    WORD        MajorImageVersion;
    WORD        MinorImageVersion;
    WORD        MajorSubsystemVersion;
    WORD        MinorSubsystemVersion;
    DWORD       Win32VersionValue;
    DWORD       SizeOfImage;
    DWORD       SizeOfHeaders;
    DWORD       CheckSum;
    WORD        Subsystem;
    WORD        DllCharacteristics;
    ULONGLONG   SizeOfStackReserve;
    ULONGLONG   SizeOfStackCommit;
    ULONGLONG   SizeOfHeapReserve;
    ULONGLONG   SizeOfHeapCommit;
    DWORD       LoaderFlags;
    DWORD       NumberOfRvaAndSizes;
;    IMAGE_DATA_DIRECTORY DataDirectory[IMAGE_NUMBEROF_DIRECTORY_ENTRIES];
ends

struct IMAGE_DATA_DIRECTORY
    DWORD   VirtualAddress;
    DWORD   Size;
ends

define IMAGE_SIZEOF_SHORT_NAME 8

struct IMAGE_SECTION_HEADER
    BYTE    Name[IMAGE_SIZEOF_SHORT_NAME];
    union
            DWORD   PhysicalAddress;
            DWORD   VirtualSize;
    ends
    DWORD   VirtualAddress;
    DWORD   SizeOfRawData;
    DWORD   PointerToRawData;
    DWORD   PointerToRelocations;
    DWORD   PointerToLinenumbers;
    WORD    NumberOfRelocations;
    WORD    NumberOfLinenumbers;
    DWORD   Characteristics;
ends

macro getdata name*, [spec*] {; getdata MZ.e_magic word, "pe_file.exe":0,2
common; 'spec' may contain comma
  virtual
    file spec
    load name from $$
  end virtual
}

irp pair, byte 1, word 2, dword 4, qword 8 {
  match !type !size, pair \{
    macro get\#!type name*, offset* \\{ getdata name !type, filename:offset, !size \\}
    macro assert\#!type name*, offset*, value* \\{
      get\#!type name, offset
      assert name=value
    \\}
  \}
}

macro copydata [spec*] { common file filename:spec }
struc copydata [spec*] { common .: copydata spec }
struc copystruct struct_name*, offset* {; accepts 'struct[count]' as 'struct_name'
common
  _name equ struct_name
  _count equ 1
  match !name[!count], struct_name \{
    _name reequ !name
    _count reequ !count
  \}
  match !name !count, _name _count \{
    virtual
      . !name
      sizeof.#. = $-.; actually it's 'count' times bigger
    end virtual
    copydata offset, sizeof.\#!name*!count
  \}
  restore _name, _count
}

macro load [arg*] {; accepts 'array[index].field' as an address
  _arg equ arg
  match !name !type =from !array[!index]!field, arg \{
    _arg reequ !name !type from !array\#!field+(!index)*sizeof.\#!array
  \}
  load _arg
  restore _arg
}

macro store arg* {; accepts 'array[index].field' as an address
  _arg equ arg
  match !name !type =at !array[!index]!field, arg \{
    _arg reequ !name !type at !array\#!field+(!index)*sizeof.\#!array
  \}
  store _arg
  restore _arg
}

macro align value { rb (value-1)-($+value-1) mod value }

;;; Ready, set, GO!
format binary as "Exe"

assertword MZ.signature, 0, 'MZ'
getdword PE, 0x3C
assertdword PE.signature, PE, 'PE'
PE.FileHeader = PE+4
PE.OptionalHeader = PE.FileHeader+sizeof.IMAGE_FILE_HEADER

file stubname
store dword newPE at 0x3C

;;; Copy signature and file header
newPE copydata PE, 4
newPE.FileHeader copystruct IMAGE_FILE_HEADER, PE.FileHeader

;;; Copy optional header (w/o data directory)
getword PE.Magic, PE.OptionalHeader
if PE.Magic=0x010B
  newPE.OptionalHeader copystruct IMAGE_OPTIONAL_HEADER, PE.OptionalHeader
else if PE.Magic=0x020B
  newPE.OptionalHeader copystruct IMAGE_OPTIONAL_HEADER64, PE.OptionalHeader
else
  err "Only PE32 and PE32+ are supported"
end if

;;; Copy data directory
PE.OptionalHeader.DataDirectory = PE.OptionalHeader+$-newPE.OptionalHeader
load newPE.NumberOfRvaAndSizes dword from newPE.OptionalHeader.NumberOfRvaAndSizes
newPE.OptionalHeader.DataDirectory copystruct IMAGE_DATA_DIRECTORY[newPE.NumberOfRvaAndSizes], PE.OptionalHeader.DataDirectory
sizeof.newPE.OptionalHeader = $-newPE.OptionalHeader

;;; Copy section headers
load newPE.NumberOfSections word from newPE.FileHeader.NumberOfSections
PE.SectionHeaders = PE.OptionalHeader+sizeof.newPE.OptionalHeader
newPE.SectionHeaders copystruct IMAGE_SECTION_HEADER[newPE.NumberOfSections], PE.SectionHeaders

;;; Copy sections
load newPE.FileAlignment dword from newPE.OptionalHeader.FileAlignment
repeat newPE.NumberOfSections
  align newPE.FileAlignment
  load SizeOfRawData dword from newPE.SectionHeaders[%-1].SizeOfRawData
  load PointerToRawData dword from newPE.SectionHeaders[%-1].PointerToRawData
  store dword $ at newPE.SectionHeaders[%-1].PointerToRawData; patch section header
  copydata PointerToRawData, SizeOfRawData
end repeat

;;; Patch OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_SECURITY].VirtualAddress, if present
;;; Signature'll become invalid anyway
IMAGE_DIRECTORY_ENTRY_SECURITY = 4
if newPE.NumberOfRvaAndSizes>IMAGE_DIRECTORY_ENTRY_SECURITY
  load PE.Certificate.VirtualAddress dword\
       from newPE.OptionalHeader.DataDirectory.VirtualAddress+sizeof.IMAGE_DATA_DIRECTORY*IMAGE_DIRECTORY_ENTRY_SECURITY
  if PE.Certificate.VirtualAddress
    store dword PE.Certificate.VirtualAddress+$-(PointerToRawData+SizeOfRawData)\
          at newPE.OptionalHeader.DataDirectory.VirtualAddress+sizeof.IMAGE_DATA_DIRECTORY*IMAGE_DIRECTORY_ENTRY_SECURITY
  end if
end if

;;; Copy trailer
copydata PointerToRawData+SizeOfRawData