मैं कैसे सुनिश्चित कर सकता हूं कि मेरे प्रोग्राम में पास की गई फ़ाइल एक वैध exe फ़ाइल है?यह कैसे ढूंढें कि फ़ाइल एक exe है या नहीं?
असल में मेरा प्रोग्राम इनपुट के रूप में फ़ाइल लेता है और इसे चलाता है, लेकिन उपयोगकर्ता किसी भी फाइल को इनपुट कर सकता है, इसलिए मुझे यह सुनिश्चित करना होगा कि इनपुट एक मान्य exe है।
यह "वैधता" की आपकी परिभाषा पर निर्भर करता है।
एक बहुत ही आदिम जांच फाइल एक्सटेंशन के लिए जाँच करने के लिए होगा:
Path.GetExtension(filename).Equals(".exe",
StringComparison.InvariantCultureIgnoreCase);
तथापि, Windows निष्पादन योग्य फ़ाइलों के लिए एक्सटेंशन की एक किस्म का समर्थन करता है (उदाहरण के लिए .cmd, .com, .cpl, .scr और many more), इसलिए ऊपर की जांच सभी निष्पादन योग्य फ़ाइलों को शामिल नहीं करेगी।
जैसा कि अन्य लोगों ने बताया है, आप उदाहरण के लिए फ़ाइल शीर्षलेख में जादू संख्याओं को भी देख सकते हैं। एमजेड (और कुछ अन्य दुर्लभ हस्ताक्षर)। यह दूसरी जांच एक्सटेंशन (ओं) की जांच के अलावा भी उपयोग की जा सकती है, हालांकि आप कभी भी यह सुनिश्चित नहीं कर सकते कि फाइल एक साधारण पाठ फ़ाइल को गलती से उसी पाठ से शुरू नहीं कर रही है।
आप निष्पादन योग्य शुरू करने जा रहे हैं, तो वैसे भी जांच की जानी है, तो यह शायद है सबसे सुरक्षित बस उचित अपवाद हैंडलिंग के साथ इसे शुरू करने के लिए:
const int ERROR_BAD_EXE_FORMAT = 193;
try
{
ProcessStartInfo psi = new ProcessStartInfo();
psi.UseShellExecute = false;
psi.FileName = @"C:\tmp\testOLElocal_4.docx";
Process.Start(psi);
}
catch (Win32Exception ex)
{
if (ex.NativeErrorCode == ERROR_BAD_EXE_FORMAT)
{
// The exception message would be
// "The specified executable is not a valid application for this OS platform."
//
Console.WriteLine("Not a valid executable.");
}
else
{
throw;
}
}
एनबी: आप अपने खुद के बारे में कोई विवरण का उल्लेख नहीं था आवेदन, लेकिन उपयोगकर्ता इनपुट के माध्यम से आने वाले कोड को निष्पादित करते समय आपको यह सुनिश्चित करना चाहिए कि आपके उपयोगकर्ता पर भरोसा किया जा सके।
परीक्षण करें यदि यह आपके हाथ में डालकर जलता है? आपको यकीन है कि एक जवाब होगा, लेकिन मुझे यकीन नहीं है कि ओपी वास्तव में क्या है; ओ) – Vinzz
क्या होगा अगर मैं destoroyeverything.exe पास करता हूं? – bniwredyc
@ विंज़, निश्चित रूप से आप हमेशा फ़ाइल एक्सटेंशन और जादू संख्याओं की जांच कर सकते हैं, बीटीयू निश्चित रूप से निश्चित है कि वास्तव में फ़ाइल को निष्पादित करने के लिए आपको प्रयास करना होगा। और यदि आवेदन फ़ाइल शुरू करेगा, वैसे भी उचित अपवाद हैंडलिंग जाने का तरीका होगा। –
तुम सिर्फ फाइल एक्सटेंशन जाँच करना चाहते हैं:
if (String.Equals(Path.GetExtension(filePath), ".exe", StringComparison.InvariantCultureIgnoreCase))
{
...
}
जांच सकते कि फ़ाइल वास्तव में निष्पादन योग्य है आप अपने हैडर विश्लेषण कर सकते हैं की जरूरत है। .exe फ़ाइल शीर्षलेख के बारे में जानकारी है: link।
तुम भी फ़ाइल 0xA3 सुझाव
आप अधिक गहराई से कुछ से चाहते हैं के रूप में चलाने की कोशिश कर सकते हैं " '.exe' में फ़ाइल नाम अंत है?" लेकिन आप वास्तव में कार्यक्रम चलाने के लिए नहीं चाहते हैं, आप पीई शीर्षकों के अस्तित्व और वैधता की जांच कर सकते हैं। इसके अतिरिक्त, अग्रणी 2 बाइट्स (पीई फाइलों के लिए "एमजेड") की जांच करना डीएलएल के लिए भी सच होगा। यदि आप यह नहीं चाहते हैं, तो आप इस दृष्टिकोण को आजमा सकते हैं।
मैट पिएट्रेक पीई प्रारूप का वर्णन महान लेख के एक जोड़े ने लिखा है:
दो महत्वपूर्ण डेटा यहां संरचनाओं IMAGE_DOS_HEADER और IMAGE_NT_HEADERS32/IMAGE_NT_HEADERS64 हैं।इन संरचनाओं को विंडोज एसडीके में winnt.h में परिभाषित किया गया है। इनमें से कई पीई संरचनाओं का वर्णन here है।
आप प्रबंधित कोड का उपयोग कर पीई शीर्षकों के साथ काम कर सकते हैं (this approach के समान)। निम्नलिखित कोड 32- (i386) और 64-बिट (आईए 64, एएमडी 64) .exe पीई फाइलों के लिए सच है (उदा। डीएलएल के लिए झूठी रिटर्न)। उपयोग के लिए नीचे देखें (ExeChecker.IsValidExe)। अगर वांछित है, तो आप अधिक आर्किटेक्चर का समर्थन करने के लिए या अधिक सत्यापन करने के लिए अतिरिक्त चेक जोड़ सकते हैं। अधिक स्थिरांक के लिए winnt.h देखें।
using System;
using System.IO;
using System.Runtime.InteropServices;
namespace ExeChecker
{
[StructLayout(LayoutKind.Sequential)]
struct IMAGE_DOS_HEADER
{
public ushort e_magic; // Magic number
public ushort e_cblp; // Bytes on last page of file
public ushort e_cp; // Pages in file
public ushort e_crlc; // Relocations
public ushort e_cparhdr; // Size of header in paragraphs
public ushort e_minalloc; // Minimum extra paragraphs needed
public ushort e_maxalloc; // Maximum extra paragraphs needed
public ushort e_ss; // Initial (relative) SS value
public ushort e_sp; // Initial SP value
public ushort e_csum; // Checksum
public ushort e_ip; // Initial IP value
public ushort e_cs; // Initial (relative) CS value
public ushort e_lfarlc; // File address of relocation table
public ushort e_ovno; // Overlay number
public uint e_res1; // Reserved
public uint e_res2; // Reserved
public ushort e_oemid; // OEM identifier (for e_oeminfo)
public ushort e_oeminfo; // OEM information; e_oemid specific
public uint e_res3; // Reserved
public uint e_res4; // Reserved
public uint e_res5; // Reserved
public uint e_res6; // Reserved
public uint e_res7; // Reserved
public int e_lfanew; // File address of new exe header
}
[StructLayout(LayoutKind.Sequential)]
struct IMAGE_FILE_HEADER
{
public ushort Machine;
public ushort NumberOfSections;
public uint TimeDateStamp;
public uint PointerToSymbolTable;
public uint NumberOfSymbols;
public ushort SizeOfOptionalHeader;
public ushort Characteristics;
}
[StructLayout(LayoutKind.Sequential)]
struct IMAGE_NT_HEADERS_COMMON
{
public uint Signature;
public IMAGE_FILE_HEADER FileHeader;
}
[StructLayout(LayoutKind.Sequential)]
struct IMAGE_NT_HEADERS32
{
public uint Signature;
public IMAGE_FILE_HEADER FileHeader;
public IMAGE_OPTIONAL_HEADER32 OptionalHeader;
}
[StructLayout(LayoutKind.Sequential)]
struct IMAGE_NT_HEADERS64
{
public uint Signature;
public IMAGE_FILE_HEADER FileHeader;
public IMAGE_OPTIONAL_HEADER64 OptionalHeader;
}
[StructLayout(LayoutKind.Sequential)]
struct IMAGE_OPTIONAL_HEADER32
{
public ushort Magic;
public byte MajorLinkerVersion;
public byte MinorLinkerVersion;
public uint SizeOfCode;
public uint SizeOfInitializedData;
public uint SizeOfUninitializedData;
public uint AddressOfEntryPoint;
public uint BaseOfCode;
public uint BaseOfData;
public uint ImageBase;
public uint SectionAlignment;
public uint FileAlignment;
public ushort MajorOperatingSystemVersion;
public ushort MinorOperatingSystemVersion;
public ushort MajorImageVersion;
public ushort MinorImageVersion;
public ushort MajorSubsystemVersion;
public ushort MinorSubsystemVersion;
public uint Win32VersionValue;
public uint SizeOfImage;
public uint SizeOfHeaders;
public uint CheckSum;
public ushort Subsystem;
public ushort DllCharacteristics;
public uint SizeOfStackReserve;
public uint SizeOfStackCommit;
public uint SizeOfHeapReserve;
public uint SizeOfHeapCommit;
public uint LoaderFlags;
public uint NumberOfRvaAndSizes;
}
[StructLayout(LayoutKind.Sequential)]
struct IMAGE_OPTIONAL_HEADER64
{
public ushort Magic;
public byte MajorLinkerVersion;
public byte MinorLinkerVersion;
public uint SizeOfCode;
public uint SizeOfInitializedData;
public uint SizeOfUninitializedData;
public uint AddressOfEntryPoint;
public uint BaseOfCode;
public ulong ImageBase;
public uint SectionAlignment;
public uint FileAlignment;
public ushort MajorOperatingSystemVersion;
public ushort MinorOperatingSystemVersion;
public ushort MajorImageVersion;
public ushort MinorImageVersion;
public ushort MajorSubsystemVersion;
public ushort MinorSubsystemVersion;
public uint Win32VersionValue;
public uint SizeOfImage;
public uint SizeOfHeaders;
public uint CheckSum;
public ushort Subsystem;
public ushort DllCharacteristics;
public ulong SizeOfStackReserve;
public ulong SizeOfStackCommit;
public ulong SizeOfHeapReserve;
public ulong SizeOfHeapCommit;
public uint LoaderFlags;
public uint NumberOfRvaAndSizes;
}
static class ExeChecker
{
public static bool IsValidExe(string fileName)
{
if (!File.Exists(fileName))
return false;
try
{
using (var stream = File.OpenRead(fileName))
{
IMAGE_DOS_HEADER dosHeader = GetDosHeader(stream);
if (dosHeader.e_magic != IMAGE_DOS_SIGNATURE)
return false;
IMAGE_NT_HEADERS_COMMON ntHeader = GetCommonNtHeader(stream, dosHeader);
if (ntHeader.Signature != IMAGE_NT_SIGNATURE)
return false;
if ((ntHeader.FileHeader.Characteristics & IMAGE_FILE_DLL) != 0)
return false;
switch (ntHeader.FileHeader.Machine)
{
case IMAGE_FILE_MACHINE_I386:
return IsValidExe32(GetNtHeader32(stream, dosHeader));
case IMAGE_FILE_MACHINE_IA64:
case IMAGE_FILE_MACHINE_AMD64:
return IsValidExe64(GetNtHeader64(stream, dosHeader));
}
}
}
catch (InvalidOperationException)
{
return false;
}
return true;
}
static bool IsValidExe32(IMAGE_NT_HEADERS32 ntHeader)
{
return ntHeader.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR32_MAGIC;
}
static bool IsValidExe64(IMAGE_NT_HEADERS64 ntHeader)
{
return ntHeader.OptionalHeader.Magic == IMAGE_NT_OPTIONAL_HDR64_MAGIC;
}
static IMAGE_DOS_HEADER GetDosHeader(Stream stream)
{
stream.Seek(0, SeekOrigin.Begin);
return ReadStructFromStream<IMAGE_DOS_HEADER>(stream);
}
static IMAGE_NT_HEADERS_COMMON GetCommonNtHeader(Stream stream, IMAGE_DOS_HEADER dosHeader)
{
stream.Seek(dosHeader.e_lfanew, SeekOrigin.Begin);
return ReadStructFromStream<IMAGE_NT_HEADERS_COMMON>(stream);
}
static IMAGE_NT_HEADERS32 GetNtHeader32(Stream stream, IMAGE_DOS_HEADER dosHeader)
{
stream.Seek(dosHeader.e_lfanew, SeekOrigin.Begin);
return ReadStructFromStream<IMAGE_NT_HEADERS32>(stream);
}
static IMAGE_NT_HEADERS64 GetNtHeader64(Stream stream, IMAGE_DOS_HEADER dosHeader)
{
stream.Seek(dosHeader.e_lfanew, SeekOrigin.Begin);
return ReadStructFromStream<IMAGE_NT_HEADERS64>(stream);
}
static T ReadStructFromStream<T>(Stream stream)
{
int structSize = Marshal.SizeOf(typeof(T));
IntPtr memory = IntPtr.Zero;
try
{
memory = Marshal.AllocCoTaskMem(structSize);
if (memory == IntPtr.Zero)
throw new InvalidOperationException();
byte[] buffer = new byte[structSize];
int bytesRead = stream.Read(buffer, 0, structSize);
if (bytesRead != structSize)
throw new InvalidOperationException();
Marshal.Copy(buffer, 0, memory, structSize);
return (T)Marshal.PtrToStructure(memory, typeof(T));
}
finally
{
if (memory != IntPtr.Zero)
Marshal.FreeCoTaskMem(memory);
}
}
const ushort IMAGE_DOS_SIGNATURE = 0x5A4D; // MZ
const uint IMAGE_NT_SIGNATURE = 0x00004550; // PE00
const ushort IMAGE_FILE_MACHINE_I386 = 0x014C; // Intel 386
const ushort IMAGE_FILE_MACHINE_IA64 = 0x0200; // Intel 64
const ushort IMAGE_FILE_MACHINE_AMD64 = 0x8664; // AMD64
const ushort IMAGE_NT_OPTIONAL_HDR32_MAGIC = 0x10B; // PE32
const ushort IMAGE_NT_OPTIONAL_HDR64_MAGIC = 0x20B; // PE32+
const ushort IMAGE_FILE_DLL = 0x2000;
}
class Program
{
static int Main(string[] args)
{
if (args.Length == 0)
{
Console.WriteLine("Please specify a file name to check.");
return 1;
}
bool isValid = ExeChecker.IsValidExe(args[0]);
Console.WriteLine(isValid);
return 0;
}
}
}
धन्यवाद। इसे सही उत्तर के रूप में चिह्नित किया जाना चाहिए था। – ahmd0
bool IsExeFile(string path)
{
var twoBytes = new byte[2];
using(var fileStream = File.Open(path, FileMode.Open))
{
fileStream.Read(twoBytes, 0, 2);
}
return Encoding.UTF8.GetString(twoBytes) == "MZ";
}
इसका जादू नंबर क्या है? – GSP
@ जीएसपी: विंडोज एक्जिक्यूटिव्स एमजेड अक्षरों से शुरू होता है (यह हेक्साडेसिमल में 4 डी 5 ए है) जो मार्क ज़बिकोव्स्की के प्रारंभिक हैं जिन्होंने फ़ाइल प्रारूप तैयार किया था। यह EXE फ़ाइलों के लिए जादू संख्या है। –
मुझे लगता है (एम: 77 = 0x4D, जेड: 90 = 0x5A)। धन्यवाद! – GSP
आप देख सकते हैं एक फ़ाइल एक वैध पीई प्रारूप PE Format DLL का उपयोग कर फ़ाइल है।
पीई फाइलों में केवल निष्पादन योग्य कोड से अधिक हो सकता है। इसमें संसाधनों के साथ-साथ कोड, या केवल संसाधन और कोई कोड शामिल हो सकता है। पीई फाइलें मूल या प्रबंधित, या देशी भी हो सकती हैं लेकिन प्रबंधित कोड से जुड़ी हो सकती हैं आदि। आप जो करना चाहते हैं उसके आधार पर, इन चीजों की जांच करने में सक्षम होना उपयोगी होगा।
PE_EXE3 pef;
int ok = FALSE;
if (pef.openFile(fileNameAndPath))
{
if (pef.IsValid())
{
ok = pef.GetHasExecutableCode();
}
pef.closeFile();
}
तुम भी उपयोगी निम्नलिखित कार्य मिल सकता है:
pef.GetIsOnlyResource()
pef.GetHasExecutableCode()
pef.GetIsPureDotNetModule()
किसी भी exe के लिए, या सिर्फ नेट exe का? – leppie
कई वैध निष्पादन योग्य फ़ाइल स्वरूप हैं जिन्हें काफी आसानी से सुलझाया जा सकता है (मैं अपने betters को गणना करने के लिए छोड़ दूंगा) लेकिन मेरे पास सवाल यह है कि 'क्या आपने अपना दिमाग खो दिया है?' ;-) –
"एक्सई फ़ाइल" एक विस्तृत शब्द है ... यदि आप फ़ाइल में पहले दो बाइट्स पढ़ते हैं, तो आप जान सकते हैं कि यह EXE है यदि यह 'एमजेड' (डॉस 32 बिट EXE, या Windows PE EXE) से शुरू होता है, लेकिन आप तब तक सुनिश्चित नहीं हो सकते जब तक आप इसे चलाने का प्रयास नहीं करते। – Cipi