จะทราบได้อย่างไรว่าไฟล์ DLL ดั้งเดิมถูกคอมไพล์เป็น x64 หรือ x86?


133

ฉันต้องการตรวจสอบว่าแอสเซมบลีเนทีฟเป็นไปตาม x64 หรือ x86 จากแอปพลิเคชันโค้ดที่มีการจัดการ ( C # )

ฉันคิดว่ามันต้องอยู่ที่ไหนสักแห่งในส่วนหัว PE เนื่องจากตัวโหลดระบบปฏิบัติการจำเป็นต้องรู้ข้อมูลนี้ แต่ฉันหาไม่เจอ แน่นอนว่าฉันชอบทำในโค้ดที่มีการจัดการ แต่ถ้าจำเป็นฉันสามารถใช้ C ++ ดั้งเดิมได้


เพื่อความชัดเจน dll ที่เป็นปัญหายังเป็น. Net assembly? คุณพูด DLL ดั้งเดิมในชื่อโพสต์ แต่แอสเซมบลีเนทีฟในคำอธิบาย ... หากคุณยังคงดูโพสต์นี้ตั้งแต่วันที่ 09 :)
Vikas Gupta

1
นอกจากนี้คุณยังอาจต้องการที่จะตรวจสอบหนึ่งนี้: เช็คถ้าไม่มีการจัดการ--dll-is-32 บิตหรือ 64 บิต
Matt

คำตอบ:


143

คุณสามารถใช้DUMPBIN ได้เช่นกัน ใช้แฟล็ก/headersหรือ/allแฟล็กและส่วนหัวไฟล์แรกที่แสดงรายการ

dumpbin /headers cv210.dll

64 บิต

Microsoft (R) COFF/PE Dumper Version 10.00.30319.01
Copyright (C) Microsoft Corporation.  All rights reserved.


Dump of file cv210.dll

PE signature found

File Type: DLL

FILE HEADER VALUES
            8664 machine (x64)
               6 number of sections
        4BBAB813 time date stamp Tue Apr 06 12:26:59 2010
               0 file pointer to symbol table
               0 number of symbols
              F0 size of optional header
            2022 characteristics
                   Executable
                   Application can handle large (>2GB) addresses
                   DLL

32 บิต

Microsoft (R) COFF/PE Dumper Version 10.00.30319.01
Copyright (C) Microsoft Corporation.  All rights reserved.


Dump of file acrdlg.dll

PE signature found

File Type: DLL

FILE HEADER VALUES
             14C machine (x86)
               5 number of sections
        467AFDD2 time date stamp Fri Jun 22 06:38:10 2007
               0 file pointer to symbol table
               0 number of symbols
              E0 size of optional header
            2306 characteristics
                   Executable
                   Line numbers stripped
                   32 bit word machine
                   Debug information stripped
                   DLL

'find' สามารถทำให้ชีวิตง่ายขึ้นเล็กน้อย:

dumpbin /headers cv210.dll |find "machine"
        8664 machine (x64)

4
เป็นมิตรกับผู้ใช้มากขึ้นเล็กน้อย;)
Ant

4
DUMPBIN ใช้ไม่ได้กับ. NET EXE ฉันมี. NET EXE แบบ 64 บิตที่ DUMPBIN ระบุว่าเป็น 32 บิต ("เครื่อง 14C (x86)") แต่ Corflags ระบุว่าเป็น CPU ใด ๆ ("PE: PE32, 32BIT: 0") Dependency Walker ก็วินิจฉัยผิดด้วย
Pierre

2
จำเป็นต้องใช้mspdb100.dll:(
Dmitry

1
@Altaveron ฉันมีปัญหาเดียวกัน แต่แก้ไขได้โดยการคัดลอกไฟล์ DLL mspdb100.dllไปยังโฟลเดอร์ที่dumpbin.exeอยู่ DUMPBINสามารถทำงานได้หลังจากนั้น สำหรับผม EXE ที่<Visual Studio Install folder>\VC\binและ DLL <Visual Studio Install folder>\Common7\IDEอยู่ที่
ADTC

DUMPBIN สามารถใช้ได้จากพรอมต์คำสั่ง Visual Studio สำหรับผู้ที่ติดตั้ง Visual Studio
Alan Macdonald

55

มีวิธีที่ง่ายต่อการทำเช่นนี้กับเป็นCorFlags เปิดพรอมต์คำสั่ง Visual Studio แล้วพิมพ์ "corflags [your assembly]" คุณจะได้รับสิ่งนี้:

c: \ Program Files (x86) \ Microsoft Visual Studio 9.0 \ VC> corflags "C: \ Windows \ Microsoft.NET \ Framework \ v2.0.50727 \ System.Data.dll"

เครื่องมือแปลง Microsoft (R) .NET Framework CorFlags เวอร์ชัน 3.5.21022.8 ลิขสิทธิ์ (c) Microsoft Corporation สงวนลิขสิทธิ์.

เวอร์ชัน: v2.0.50727 CLR ส่วนหัว: 2.5 PE: PE32 CorFlags: 24 ILONLY: 0 32BIT: 0 ลงนาม: 1

คุณกำลังมองหา PE และ 32BIT โดยเฉพาะ

  • CPU ใด ๆ :

    PE: PE32 32 บิต
    : 0

  • x86 :

    PE: PE32 32 บิต
    : 1

  • x 64:

    PE: PE32 + 32 บิต
    : 0


18
@BLogan คุณควรดูความคิดเห็นของฉันต่อ Steven Behnke ด้านบน ฉันรู้จักยูทิลิตี้ corflags แต่ใช้ไม่ได้กับแอสเซมบลีเนทีฟ
Ohad Horesh

7
ผลลัพธ์ของ Corflags ใดที่เปลี่ยนแปลงในเวอร์ชันหลัง ๆ (Windows SDK 8 หรือสูงกว่า) ตอนนี้แทนที่จะเป็น 32BIT มี 32BITREQUIRED และ 32BITPREFERRED ดูคำอธิบายใน CorHdr.h ที่อยู่ C: \ Program Files (x86) \ Windows Kits \ 8.0 \ Include \ um \ CorHdr.h จากสิ่งที่ฉันบอกได้ 32BITREQUIRED แทนที่ 32BIT ดูคำตอบสำหรับคำถามนี้ด้วย
Wes

37

เคล็ดลับนี้ใช้ได้ผลและต้องใช้ Notepad เท่านั้น

เปิดไฟล์ dll โดยใช้โปรแกรมแก้ไขข้อความ (เช่น Notepad) PEและพบว่าเกิดขึ้นครั้งแรกของสตริง อักขระต่อไปนี้กำหนดว่า dll เป็น 32 หรือ 64 บิต

32 บิต:

PE  L

64 บิต:

PE  d

25

MagicเขตของIMAGE_OPTIONAL_HEADER (แม้ว่าจะมีอะไรที่ไม่จำเป็นเกี่ยวกับส่วนหัวใน Windows ภาพปฏิบัติการ (ไฟล์ DLL / EXE)) จะบอกคุณสถาปัตยกรรมของ PE ที่

นี่คือตัวอย่างของการดึงสถาปัตยกรรมจากไฟล์

public static ushort GetImageArchitecture(string filepath) {
    using (var stream = new System.IO.FileStream(filepath, System.IO.FileMode.Open, System.IO.FileAccess.Read))
    using (var reader = new System.IO.BinaryReader(stream)) {
        //check the MZ signature to ensure it's a valid Portable Executable image
        if (reader.ReadUInt16() != 23117) 
            throw new BadImageFormatException("Not a valid Portable Executable image", filepath);

        // seek to, and read, e_lfanew then advance the stream to there (start of NT header)
        stream.Seek(0x3A, System.IO.SeekOrigin.Current); 
        stream.Seek(reader.ReadUInt32(), System.IO.SeekOrigin.Begin);

        // Ensure the NT header is valid by checking the "PE\0\0" signature
        if (reader.ReadUInt32() != 17744)
            throw new BadImageFormatException("Not a valid Portable Executable image", filepath);

        // seek past the file header, then read the magic number from the optional header
        stream.Seek(20, System.IO.SeekOrigin.Current); 
        return reader.ReadUInt16();
    }
}

ค่าคงที่สถาปัตยกรรมสองอย่างในขณะนี้คือ:

0x10b - PE32
0x20b - PE32+

ไชโย

อัปเดต เป็นเวลานานแล้วที่ฉันโพสต์คำตอบนี้ แต่ฉันก็ยังเห็นว่ามันได้รับการโหวตเพิ่มขึ้นไม่กี่ครั้งแล้วครั้งเล่าดังนั้นฉันจึงคิดว่ามันคุ้มค่าที่จะอัปเดต ฉันเขียนวิธีรับสถาปัตยกรรมของPortable Executableรูปภาพซึ่งจะตรวจสอบด้วยว่าคอมไพล์เป็นAnyCPUไฟล์. น่าเสียดายที่คำตอบอยู่ใน C ++ แต่ไม่ควรยากเกินไปที่จะพอร์ตไปยัง C # หากคุณมีเวลาไม่กี่นาทีในการค้นหาโครงสร้างในWinNT.h. หากผู้คนสนใจฉันจะเขียนพอร์ตใน C # แต่ถ้าไม่มีคนต้องการจริงๆฉันจะไม่ใช้เวลากับมันมากนัก

#include <Windows.h>

#define MKPTR(p1,p2) ((DWORD_PTR)(p1) + (DWORD_PTR)(p2))

typedef enum _pe_architecture {
    PE_ARCHITECTURE_UNKNOWN = 0x0000,
    PE_ARCHITECTURE_ANYCPU  = 0x0001,
    PE_ARCHITECTURE_X86     = 0x010B,
    PE_ARCHITECTURE_x64     = 0x020B
} PE_ARCHITECTURE;

LPVOID GetOffsetFromRva(IMAGE_DOS_HEADER *pDos, IMAGE_NT_HEADERS *pNt, DWORD rva) {
    IMAGE_SECTION_HEADER *pSecHd = IMAGE_FIRST_SECTION(pNt);
    for(unsigned long i = 0; i < pNt->FileHeader.NumberOfSections; ++i, ++pSecHd) {
        // Lookup which section contains this RVA so we can translate the VA to a file offset
        if (rva >= pSecHd->VirtualAddress && rva < (pSecHd->VirtualAddress + pSecHd->Misc.VirtualSize)) {
            DWORD delta = pSecHd->VirtualAddress - pSecHd->PointerToRawData;
            return (LPVOID)MKPTR(pDos, rva - delta);
        }
    }
    return NULL;
}

PE_ARCHITECTURE GetImageArchitecture(void *pImageBase) {
    // Parse and validate the DOS header
    IMAGE_DOS_HEADER *pDosHd = (IMAGE_DOS_HEADER*)pImageBase;
    if (IsBadReadPtr(pDosHd, sizeof(pDosHd->e_magic)) || pDosHd->e_magic != IMAGE_DOS_SIGNATURE)
        return PE_ARCHITECTURE_UNKNOWN;

    // Parse and validate the NT header
    IMAGE_NT_HEADERS *pNtHd = (IMAGE_NT_HEADERS*)MKPTR(pDosHd, pDosHd->e_lfanew);
    if (IsBadReadPtr(pNtHd, sizeof(pNtHd->Signature)) || pNtHd->Signature != IMAGE_NT_SIGNATURE)
        return PE_ARCHITECTURE_UNKNOWN;

    // First, naive, check based on the 'Magic' number in the Optional Header.
    PE_ARCHITECTURE architecture = (PE_ARCHITECTURE)pNtHd->OptionalHeader.Magic;

    // If the architecture is x86, there is still a possibility that the image is 'AnyCPU'
    if (architecture == PE_ARCHITECTURE_X86) {
        IMAGE_DATA_DIRECTORY comDirectory = pNtHd->OptionalHeader.DataDirectory[IMAGE_DIRECTORY_ENTRY_COM_DESCRIPTOR];
        if (comDirectory.Size) {
            IMAGE_COR20_HEADER *pClrHd = (IMAGE_COR20_HEADER*)GetOffsetFromRva(pDosHd, pNtHd, comDirectory.VirtualAddress);
            // Check to see if the CLR header contains the 32BITONLY flag, if not then the image is actually AnyCpu
            if ((pClrHd->Flags & COMIMAGE_FLAGS_32BITREQUIRED) == 0)
                architecture = PE_ARCHITECTURE_ANYCPU;
        }
    }

    return architecture;
}

ฟังก์ชั่นนี้ยอมรับตัวชี้ไปยังภาพ PE ในหน่วยความจำ (เพื่อให้คุณสามารถเลือกพิษของคุณว่าจะรับมันอย่างไรการทำแผนที่หน่วยความจำหรืออ่านสิ่งทั้งหมดลงในหน่วยความจำ ... อะไรก็ได้)


น่าสนใจมาก แต่เมื่อฉันมีแอพพลิเคชั่นที่คอมไพล์ด้วย CPU ใด ๆ ผลลัพธ์คือ 0x10B สิ่งนี้ไม่ถูกต้องเนื่องจากแอปพลิเคชันของฉันทำงานในระบบ x64 มีธงอื่นให้ตรวจสอบหรือไม่?
ซามูเอล

3
AnyCPU หมายความว่าอย่างนั้น: AnyCPU ดังนั้นจึงแสดงรายการเป็น 0x10B ในส่วนหัว PE สำหรับความเข้ากันได้ย้อนหลังกับ 32 บิต ในการตรวจสอบความแตกต่างระหว่างสิ่งนั้นกับ 32 บิตแบบตรงคุณต้องค้นหาว่า CorFlags ได้รับแฟล็ก32BITจากที่ใดใน PE ฉันไม่รู้จากส่วนบนของหัวของฉัน
Jason Larke

@JasonLarke ฉันมาที่นี่จากการค้นหาของ Google และข้อมูลโค้ดของคุณช่วยฉัน ขอบคุณมาก!
Parag Doke

@Samuel อัปเดตเพื่อตรวจสอบแฟล็ก AnyCPU
Jason Larke

รหัส C # นั้นทำงานในกระบวนการ 64 บิตเมื่อตรวจสอบชุดประกอบ 32 บิต? ตัวอย่างเช่น Module.GetPEKind msdn.microsoft.com/en-us/library/…ล้มเหลว
Kiquenet

14

สำหรับไฟล์ DLL ที่ไม่มีการจัดการก่อนอื่นคุณต้องตรวจสอบว่าเป็นไฟล์ DLL 16 บิตหรือไม่ (หวังว่าจะไม่ใช่) จากนั้นตรวจสอบIMAGE\_FILE_HEADER.Machineฟิลด์

มีคนอื่นใช้เวลาในการแก้ไขปัญหานี้อยู่แล้วดังนั้นฉันจะพูดซ้ำที่นี่:

หากต้องการแยกความแตกต่างระหว่างไฟล์ PE 32 บิตและ 64 บิตคุณควรตรวจสอบฟิลด์ IMAGE_FILE_HEADER.Machine ตามข้อกำหนด Microsoft PE และ COFF ด้านล่างฉันได้ระบุค่าที่เป็นไปได้ทั้งหมดสำหรับฟิลด์นี้: http://download.microsoft.com/download/9/c/5/9c5b2167-8017-4bae-9fde-d599bac8184a/ pecoff_v8.doc

IMAGE_FILE_MACHINE_UNKNOWN 0x0 เนื้อหาของฟิลด์นี้ถือว่าใช้ได้กับเครื่องทุกประเภท

IMAGE_FILE_MACHINE_AM33 0x1d3 Matsushita AM33

IMAGE_FILE_MACHINE_AMD64 0x8664 x64

IMAGE_FILE_MACHINE_ARM 0x1c0 ARM endian ตัวน้อย

IMAGE_FILE_MACHINE_EBC 0xebc รหัส EFI ไบต์

IMAGE_FILE_MACHINE_I386 0x14c โปรเซสเซอร์ Intel 386 หรือใหม่กว่าและโปรเซสเซอร์ที่เข้ากันได้

IMAGE_FILE_MACHINE_IA64 0x200 ตระกูลโปรเซสเซอร์ Intel Itanium

IMAGE_FILE_MACHINE_M32R 0x9041 Mitsubishi M32R endian ตัวน้อย

IMAGE_FILE_MACHINE_MIPS16 0x266 MIPS16

IMAGE_FILE_MACHINE_MIPSFPU 0x366 MIPS พร้อม FPU

IMAGE_FILE_MACHINE_MIPSFPU16 0x466 MIPS16 พร้อม FPU

IMAGE_FILE_MACHINE_POWERPC 0x1f0 Power PC ตัวน้อย endian

IMAGE_FILE_MACHINE_POWERPCFP 0x1f1 Power PC พร้อมการสนับสนุนจุดลอยตัว

IMAGE_FILE_MACHINE_R4000 0x166 MIPS endian น้อย

IMAGE_FILE_MACHINE_SH3 0x1a2 Hitachi SH3

IMAGE_FILE_MACHINE_SH3DSP 0x1a3 Hitachi SH3 DSP

IMAGE_FILE_MACHINE_SH4 0x1a6 Hitachi SH4

IMAGE_FILE_MACHINE_SH5 0x1a8 Hitachi SH5

IMAGE_FILE_MACHINE_THUMB 0x1c2 Thumb

IMAGE_FILE_MACHINE_WCEMIPSV2 0x169 MIPS WCE v2 น้อยที่สุด

ได้คุณสามารถตรวจสอบ IMAGE_FILE_MACHINE_AMD64 | IMAGE_FILE_MACHINE_IA64 สำหรับ 64 บิตและ IMAGE_FILE_MACHINE_I386 สำหรับ 32 บิต


ลิงค์ที่สองของคุณหมดแล้ว: s
gpalex



3

เปิด dll ด้วยโปรแกรมแก้ไขฐานสิบหกเช่นHxD

หากมี "dt" ที่บรรทัดที่ 9 แสดงว่าเป็น 64 บิต

ถ้ามี "ล." ในบรรทัดที่ 9 คือ 32 บิต


ไม่พบ "dt" และ "L. " ในโปรแกรมดู HEX "Far Manager"
Dmitry

แสดงเป็น d. และ L.
Zax

1

ฉันเขียนโซลูชัน c ++ ใหม่ในคำตอบแรกในสคริปต์ powershell สคริปต์สามารถกำหนดประเภทของไฟล์. exe และ. dll นี้ได้:

#Description       C# compiler switch             PE type       machine corflags
#MSIL              /platform:anycpu (default)     PE32  x86     ILONLY
#MSIL 32 bit pref  /platform:anycpu32bitpreferred PE32  x86     ILONLY | 32BITREQUIRED | 32BITPREFERRED
#x86 managed       /platform:x86                  PE32  x86     ILONLY | 32BITREQUIRED
#x86 mixed         n/a                            PE32  x86     32BITREQUIRED
#x64 managed       /platform:x64                  PE32+ x64     ILONLY
#x64 mixed         n/a                            PE32+ x64  
#ARM managed       /platform:arm                  PE32  ARM     ILONLY
#ARM mixed         n/a                            PE32  ARM  

โซลูชันนี้มีข้อดีกว่า corflags.exe และการโหลดแอสเซมบลีผ่าน Assembly โหลดใน C # - คุณจะไม่ได้รับ BadImageFormatException หรือข้อความเกี่ยวกับส่วนหัวที่ไม่ถูกต้อง

function GetActualAddressFromRVA($st, $sec, $numOfSec, $dwRVA)
{
    [System.UInt32] $dwRet = 0;
    for($j = 0; $j -lt $numOfSec; $j++)   
    {   
        $nextSectionOffset = $sec + 40*$j;
        $VirtualSizeOffset = 8;
        $VirtualAddressOffset = 12;
        $SizeOfRawDataOffset = 16;
        $PointerToRawDataOffset = 20;

    $Null = @(
        $curr_offset = $st.BaseStream.Seek($nextSectionOffset + $VirtualSizeOffset, [System.IO.SeekOrigin]::Begin);        
        [System.UInt32] $VirtualSize = $b.ReadUInt32();
        [System.UInt32] $VirtualAddress = $b.ReadUInt32();
        [System.UInt32] $SizeOfRawData = $b.ReadUInt32();
        [System.UInt32] $PointerToRawData = $b.ReadUInt32();        

        if ($dwRVA -ge $VirtualAddress -and $dwRVA -lt ($VirtualAddress + $VirtualSize)) {
            $delta = $VirtualAddress - $PointerToRawData;
            $dwRet = $dwRVA - $delta;
            return $dwRet;
        }
        );
    }
    return $dwRet;
}

function Get-Bitness2([System.String]$path, $showLog = $false)
{
    $Obj = @{};
    $Obj.Result = '';
    $Obj.Error = $false;

    $Obj.Log = @(Split-Path -Path $path -Leaf -Resolve);

    $b = new-object System.IO.BinaryReader([System.IO.File]::Open($path,[System.IO.FileMode]::Open,[System.IO.FileAccess]::Read, [System.IO.FileShare]::Read));
    $curr_offset = $b.BaseStream.Seek(0x3c, [System.IO.SeekOrigin]::Begin)
    [System.Int32] $peOffset = $b.ReadInt32();
    $Obj.Log += 'peOffset ' + "{0:X0}" -f $peOffset;

    $curr_offset = $b.BaseStream.Seek($peOffset, [System.IO.SeekOrigin]::Begin);
    [System.UInt32] $peHead = $b.ReadUInt32();

    if ($peHead -ne 0x00004550) {
        $Obj.Error = $true;
        $Obj.Result = 'Bad Image Format';
        $Obj.Log += 'cannot determine file type (not x64/x86/ARM) - exit with error';
    };

    if ($Obj.Error)
    {
        $b.Close();
        Write-Host ($Obj.Log | Format-List | Out-String);
        return $false;
    };

    [System.UInt16] $machineType = $b.ReadUInt16();
    $Obj.Log += 'machineType ' + "{0:X0}" -f $machineType;

    [System.UInt16] $numOfSections = $b.ReadUInt16();
    $Obj.Log += 'numOfSections ' + "{0:X0}" -f $numOfSections;
    if (($machineType -eq 0x8664) -or ($machineType -eq 0x200)) { $Obj.Log += 'machineType: x64'; }
    elseif ($machineType -eq 0x14c)                             { $Obj.Log += 'machineType: x86'; }
    elseif ($machineType -eq 0x1c0)                             { $Obj.Log += 'machineType: ARM'; }
    else{
        $Obj.Error = $true;
        $Obj.Log += 'cannot determine file type (not x64/x86/ARM) - exit with error';
    };

    if ($Obj.Error) {
        $b.Close();
        Write-Output ($Obj.Log | Format-List | Out-String);
        return $false;
    };

    $curr_offset = $b.BaseStream.Seek($peOffset+20, [System.IO.SeekOrigin]::Begin);
    [System.UInt16] $sizeOfPeHeader = $b.ReadUInt16();

    $coffOffset = $peOffset + 24;#PE header size is 24 bytes
    $Obj.Log += 'coffOffset ' + "{0:X0}" -f $coffOffset;

    $curr_offset = $b.BaseStream.Seek($coffOffset, [System.IO.SeekOrigin]::Begin);#+24 byte magic number
    [System.UInt16] $pe32 = $b.ReadUInt16();         
    $clr20headerOffset = 0;
    $flag32bit = $false;
    $Obj.Log += 'pe32 magic number: ' + "{0:X0}" -f $pe32;
    $Obj.Log += 'size of optional header ' + ("{0:D0}" -f $sizeOfPeHeader) + " bytes";

    #COMIMAGE_FLAGS_ILONLY               =0x00000001,
    #COMIMAGE_FLAGS_32BITREQUIRED        =0x00000002,
    #COMIMAGE_FLAGS_IL_LIBRARY           =0x00000004,
    #COMIMAGE_FLAGS_STRONGNAMESIGNED     =0x00000008,
    #COMIMAGE_FLAGS_NATIVE_ENTRYPOINT    =0x00000010,
    #COMIMAGE_FLAGS_TRACKDEBUGDATA       =0x00010000,
    #COMIMAGE_FLAGS_32BITPREFERRED       =0x00020000,

    $COMIMAGE_FLAGS_ILONLY        = 0x00000001;
    $COMIMAGE_FLAGS_32BITREQUIRED = 0x00000002;
    $COMIMAGE_FLAGS_32BITPREFERRED = 0x00020000;

    $offset = 96;
    if ($pe32 -eq 0x20b) {
        $offset = 112;#size of COFF header is bigger for pe32+
    }     

    $clr20dirHeaderOffset = $coffOffset + $offset + 14*8;#clr directory header offset + start of section number 15 (each section is 8 byte long);
    $Obj.Log += 'clr20dirHeaderOffset ' + "{0:X0}" -f $clr20dirHeaderOffset;
    $curr_offset = $b.BaseStream.Seek($clr20dirHeaderOffset, [System.IO.SeekOrigin]::Begin);
    [System.UInt32] $clr20VirtualAddress = $b.ReadUInt32();
    [System.UInt32] $clr20Size = $b.ReadUInt32();
    $Obj.Log += 'clr20VirtualAddress ' + "{0:X0}" -f $clr20VirtualAddress;
    $Obj.Log += 'clr20SectionSize ' + ("{0:D0}" -f $clr20Size) + " bytes";

    if ($clr20Size -eq 0) {
        if ($machineType -eq 0x1c0) { $Obj.Result = 'ARM native'; }
        elseif ($pe32 -eq 0x10b)    { $Obj.Result = '32-bit native'; }
        elseif($pe32 -eq 0x20b)     { $Obj.Result = '64-bit native'; }

       $b.Close();   
       if ($Obj.Result -eq '') { 
            $Obj.Error = $true;
            $Obj.Log += 'Unknown type of file';
       }
       else { 
            if ($showLog) { Write-Output ($Obj.Log | Format-List | Out-String); };
            return $Obj.Result;
       }
    };

    if ($Obj.Error) {
        $b.Close();
        Write-Host ($Obj.Log | Format-List | Out-String);
        return $false;
    };

    [System.UInt32]$sectionsOffset = $coffOffset + $sizeOfPeHeader;
    $Obj.Log += 'sectionsOffset ' + "{0:X0}" -f $sectionsOffset;
    $realOffset = GetActualAddressFromRVA $b $sectionsOffset $numOfSections $clr20VirtualAddress;
    $Obj.Log += 'real IMAGE_COR20_HEADER offset ' + "{0:X0}" -f $realOffset;
    if ($realOffset -eq 0) {
        $Obj.Error = $true;
        $Obj.Log += 'cannot find COR20 header - exit with error';
        $b.Close();
        return $false;
    };

    if ($Obj.Error) {
        $b.Close();
        Write-Host ($Obj.Log | Format-List | Out-String);
        return $false;
    };

    $curr_offset = $b.BaseStream.Seek($realOffset + 4, [System.IO.SeekOrigin]::Begin);
    [System.UInt16] $majorVer = $b.ReadUInt16();
    [System.UInt16] $minorVer = $b.ReadUInt16();
    $Obj.Log += 'IMAGE_COR20_HEADER version ' + ("{0:D0}" -f $majorVer) + "." + ("{0:D0}" -f $minorVer);

    $flagsOffset = 16;#+16 bytes - flags field
    $curr_offset = $b.BaseStream.Seek($realOffset + $flagsOffset, [System.IO.SeekOrigin]::Begin);
    [System.UInt32] $flag32bit = $b.ReadUInt32();
    $Obj.Log += 'CorFlags: ' + ("{0:X0}" -f $flag32bit);

#Description       C# compiler switch             PE type       machine corflags
#MSIL              /platform:anycpu (default)     PE32  x86     ILONLY
#MSIL 32 bit pref  /platform:anycpu32bitpreferred PE32  x86     ILONLY | 32BITREQUIRED | 32BITPREFERRED
#x86 managed       /platform:x86                  PE32  x86     ILONLY | 32BITREQUIRED
#x86 mixed         n/a                            PE32  x86     32BITREQUIRED
#x64 managed       /platform:x64                  PE32+ x64     ILONLY
#x64 mixed         n/a                            PE32+ x64  
#ARM managed       /platform:arm                  PE32  ARM     ILONLY
#ARM mixed         n/a                            PE32  ARM  

    $isILOnly = ($flag32bit -band $COMIMAGE_FLAGS_ILONLY) -eq $COMIMAGE_FLAGS_ILONLY;
    $Obj.Log += 'ILONLY: ' + $isILOnly;
    if ($machineType -eq 0x1c0) {#if ARM
        if ($isILOnly) { $Obj.Result = 'ARM managed'; } 
                  else { $Obj.Result = 'ARM mixed'; }
    }
    elseif ($pe32 -eq 0x10b) {#pe32
        $is32bitRequired = ($flag32bit -band $COMIMAGE_FLAGS_32BITREQUIRED) -eq $COMIMAGE_FLAGS_32BITREQUIRED;
        $is32bitPreffered = ($flag32bit -band $COMIMAGE_FLAGS_32BITPREFERRED) -eq $COMIMAGE_FLAGS_32BITPREFERRED;
        $Obj.Log += '32BIT: ' + $is32bitRequired;    
        $Obj.Log += '32BIT PREFFERED: ' + $is32bitPreffered 
        if     ($is32bitRequired  -and $isILOnly  -and $is32bitPreffered) { $Obj.Result = 'AnyCpu 32bit-preffered'; }
        elseif ($is32bitRequired  -and $isILOnly  -and !$is32bitPreffered){ $Obj.Result = 'x86 managed'; }
        elseif (!$is32bitRequired -and !$isILOnly -and $is32bitPreffered) { $Obj.Result = 'x86 mixed'; }
        elseif ($isILOnly)                                                { $Obj.Result = 'AnyCpu'; }
   }
   elseif ($pe32 -eq 0x20b) {#pe32+
        if ($isILOnly) { $Obj.Result = 'x64 managed'; } 
                  else { $Obj.Result = 'x64 mixed'; }
   }

   $b.Close();   
   if ($showLog) { Write-Host ($Obj.Log | Format-List | Out-String); }
   if ($Obj.Result -eq ''){ return 'Unknown type of file';};
   $flags = '';
   if ($isILOnly) {$flags += 'ILONLY';}
   if ($is32bitRequired) {
        if ($flags -ne '') {$flags += ' | ';}
        $flags += '32BITREQUIRED';
   }
   if ($is32bitPreffered) {
        if ($flags -ne '') {$flags += ' | ';}
        $flags += '32BITPREFERRED';
   }
   if ($flags -ne '') {$flags = ' (' + $flags +')';}
   return $Obj.Result + $flags;
}

ตัวอย่างการใช้งาน:

#$filePath = "C:\Windows\SysWOW64\regedit.exe";#32 bit native on 64bit windows
$filePath = "C:\Windows\regedit.exe";#64 bit native on 64bit windows | should be 32 bit native on 32bit windows

Get-Bitness2 $filePath $true;

คุณสามารถละเว้นพารามิเตอร์ที่สองได้หากไม่ต้องการดูรายละเอียด


1

วิธีที่รวดเร็วและอาจจะสกปรกที่จะทำมันได้อธิบายไว้ที่นี่: https://superuser.com/a/889267 คุณเปิด DLL ในโปรแกรมแก้ไขและตรวจสอบอักขระตัวแรกหลังลำดับ "PE"


0

เห็นได้ชัดว่าคุณสามารถพบได้ในส่วนหัวของไฟล์ปฏิบัติการแบบพกพา ยูทิลิตี้ corflags.exe สามารถแสดงให้คุณเห็นว่ามีเป้าหมายเป็น x64 หรือไม่ หวังว่านี่จะช่วยให้คุณพบข้อมูลเพิ่มเติมเกี่ยวกับเรื่องนี้


3
ขอบคุณสตีเวน แต่ corflags.exe ใช้ไม่ได้กับแอสเซมบลีเนทีฟ
Ohad Horesh

1
Windows 10:>corflags libzmq.dll \n\n ... corflags : error CF008 : The specified file does not have a valid managed header
Grault
โดยการใช้ไซต์ของเรา หมายความว่าคุณได้อ่านและทำความเข้าใจนโยบายคุกกี้และนโยบายความเป็นส่วนตัวของเราแล้ว
Licensed under cc by-sa 3.0 with attribution required.