예제 #1
0
        public void TestContainsResourcesForAllSupportedPlatforms()
        {
            if (RuntimeInformation.IsOSPlatform(OSPlatform.Windows))
            {
                void AssertIs32BitHeader(MemoryStream memoryStream, bool isTrue)
                {
                    if (memoryStream == null)
                    {
                        throw new ArgumentNullException(nameof(memoryStream));
                    }
                    var peUtility = new PeUtility(memoryStream);

                    Assert.Equal(isTrue, peUtility.Is32BitHeader);
                }

                #if PLATFORM_WINDOWS_X86
                Assert.NotNull(_snapxEmbeddedResources.SetupWindowsX86);
                Assert.NotNull(_snapxEmbeddedResources.WarpPackerWindowsX86);
                AssertIs32BitHeader(_snapxEmbeddedResources.WarpPackerWindowsX86, true);
                #elif PLATFORM_WINDOWS_X64
                Assert.NotNull(_snapxEmbeddedResources.SetupWindowsX64);
                Assert.NotNull(_snapxEmbeddedResources.WarpPackerWindowsX64);
                AssertIs32BitHeader(_snapxEmbeddedResources.WarpPackerWindowsX64, false);
                #else
                // 32-bit
                Assert.NotNull(_snapxEmbeddedResources.SetupWindowsX86);
                Assert.NotNull(_snapxEmbeddedResources.WarpPackerWindowsX86);
                AssertIs32BitHeader(_snapxEmbeddedResources.WarpPackerWindowsX86, true);

                // 64-bit
                Assert.NotNull(_snapxEmbeddedResources.SetupWindowsX64);
                Assert.NotNull(_snapxEmbeddedResources.WarpPackerWindowsX64);
                AssertIs32BitHeader(_snapxEmbeddedResources.WarpPackerWindowsX64, false);
                #endif
                return;
            }

            if (RuntimeInformation.IsOSPlatform(OSPlatform.Linux))
            {
                if (RuntimeInformation.ProcessArchitecture == Architecture.X64)
                {
                    Assert.NotNull(_snapxEmbeddedResources.SetupLinuxX64);
                    Assert.NotNull(_snapxEmbeddedResources.WarpPackerLinuxX64);
                    return;
                }

                if (RuntimeInformation.ProcessArchitecture == Architecture.Arm64)
                {
                    Assert.NotNull(_snapxEmbeddedResources.SetupLinuxArm64);
                    Assert.NotNull(_snapxEmbeddedResources.WarpPackerLinuxArm64);
                    return;
                }
            }

            throw new PlatformNotSupportedException();
        }
예제 #2
0
        public static (PeUtility.SubSystemType subSystemType, bool is32Bit, bool is64Bit) GetPeDetails([NotNull] this Stream srcStream)
        {
            if (srcStream == null)
            {
                throw new ArgumentNullException(nameof(srcStream));
            }
            using var peFile = new PeUtility(srcStream);
            var subsysVal = peFile.Is32BitHeader ? (PeUtility.SubSystemType)peFile.OptionalHeader32.Subsystem : (PeUtility.SubSystemType)peFile.OptionalHeader64.Subsystem;

            return(subsysVal, peFile.Is32BitHeader, !peFile.Is32BitHeader);
        }
예제 #3
0
        public static bool ChangeSubsystemToWindowsGui([NotNull] this Stream srcStream, ILog logger = null)
        {
            if (srcStream == null)
            {
                throw new ArgumentNullException(nameof(srcStream));
            }
            using var peFile = new PeUtility(srcStream);
            var subsysOffset = peFile.MainHeaderOffset;
            var headerType   = peFile.Is32BitHeader ?
                               typeof(PeUtility.IMAGE_OPTIONAL_HEADER32) :
                               typeof(PeUtility.IMAGE_OPTIONAL_HEADER64);

            var subsysVal = peFile.Is32BitHeader ?
                            (PeUtility.SubSystemType)peFile.OptionalHeader32.Subsystem :
                            (PeUtility.SubSystemType)peFile.OptionalHeader64.Subsystem;

            subsysOffset += Marshal.OffsetOf(headerType, "Subsystem").ToInt32();

            switch (subsysVal)
            {
            case PeUtility.SubSystemType.IMAGE_SUBSYSTEM_WINDOWS_GUI:
                logger?.Info("Executable file is already a Win32 App!");
                return(true);

            case PeUtility.SubSystemType.IMAGE_SUBSYSTEM_WINDOWS_CUI:

                var subsysSetting = BitConverter.GetBytes((ushort)PeUtility.SubSystemType.IMAGE_SUBSYSTEM_WINDOWS_GUI);

                if (!BitConverter.IsLittleEndian)
                {
                    Array.Reverse(subsysSetting);
                }

                if (peFile.Stream.CanWrite)
                {
                    peFile.Stream.Seek(subsysOffset, SeekOrigin.Begin);
                    peFile.Stream.Write(subsysSetting, 0, subsysSetting.Length);
                }
                else
                {
                    logger.Error("Can't write changes! Conversion failed...");
                }

                return(true);

            default:
                logger.Error($"Unsupported subsystem : {Enum.GetName(typeof(PeUtility.SubSystemType), subsysVal)}.");
                return(false);
            }
        }
예제 #4
0
        private bool ProcessFile(string exeFilePath)
        {
            Log.LogMessage("NSubsys Subsystem Changer for Windows PE files.");
            Log.LogMessage($"[NSubsys] Target EXE `{exeFilePath}`.");

            using (var peFile = new PeUtility(exeFilePath))
            {
                SubSystemType subsysVal;
                var           subsysOffset = peFile.MainHeaderOffset;

                subsysVal     = (SubSystemType)peFile.OptionalHeader.Subsystem;
                subsysOffset += Marshal.OffsetOf <IMAGE_OPTIONAL_HEADER>("Subsystem").ToInt32();

                switch (subsysVal)
                {
                case PeUtility.SubSystemType.IMAGE_SUBSYSTEM_WINDOWS_GUI:
                    Log.LogWarning("Executable file is already a Win32 App!");
                    return(true);

                case PeUtility.SubSystemType.IMAGE_SUBSYSTEM_WINDOWS_CUI:
                    Log.LogMessage("Console app detected...");
                    Log.LogMessage("Converting...");

                    var subsysSetting = BitConverter.GetBytes((ushort)SubSystemType.IMAGE_SUBSYSTEM_WINDOWS_GUI);

                    if (!BitConverter.IsLittleEndian)
                    {
                        Array.Reverse(subsysSetting);
                    }

                    if (peFile.Stream.CanWrite)
                    {
                        peFile.Stream.Seek(subsysOffset, SeekOrigin.Begin);
                        peFile.Stream.Write(subsysSetting, 0, subsysSetting.Length);
                        Log.LogMessage("Conversion Complete...");
                    }
                    else
                    {
                        Log.LogMessage("Can't write changes!");
                        Log.LogMessage("Conversion Failed...");
                    }

                    return(true);

                default:
                    Log.LogMessage($"Unsupported subsystem : {Enum.GetName(typeof(SubSystemType), subsysVal)}.");
                    return(false);
                }
            }
        }