Вопросы по С#

firon · 03.06.2023

когда приложение падает

Когда werfault.exe сработал, ты уже ничего не можешь сделать, ты упал.

Приложение не падает - оно просто сильно исользует CPU несколько секунд (5-15 с) и после это продолжает работать так как и должно. Что в ити 5-15 секунд происходит, что оно так CPU поедает - загадка

T-HAX_C · 09.06.2023

Доброго времени суток господа! Подскажите, хочу ради опыта попробовать написать свой backdoor на языке С#, с каких библиотек стоит начать изучение? А если есть отдельная статья по этому, то прошу поделиться со мной. Заранее спасибо)

Burnbrighter · 10.06.2023

T-HAX_C сказал(а):

Доброго времени суток господа! Подскажите, хочу ради опыта попробовать написать свой backdoor на языке С#, с каких библиотек стоит начать изучение? А если есть отдельная статья по этому, то прошу поделиться со мной. Заранее спасибо)

Посмотри как реализовываются клиент серверные приложения, например чат. Тут тебе помогут классы TcpListener, TcpClient
Для вызова команд CMD/командлетов Powershell класс Process

firon · 22.06.2023

1) Как обфусцировать *исходный код*?
2) Какое свойство нужно добавить в .csproj чтобы в бинарник не добавлялась никакя информация, кроме самой необходимой? Как убрать дебаг-символы я знаю. Вопрос в том как сделать так, чтобы когда бросаеться исключение оно не давало никой информации: т.е. чтобы вместо "at AppHelloWorld.Program.Main() 0x423" было что-то вроде "ERR_0x7D3EA0" или "_hjajKA_.Podfs.Main() 0x131".
3) Вот если мой бинарник запускают из памяти, а не из диска, как мне тогда получить все байты моего бинарника? При запуске с диска я могу просто молучить локацию, где находится бинарник и прочесть из файла байты - а как прочесть байты бинарника если его запускают из памяти? В этом случае я даже получить путь к файлу не могу, ибо он существует в пямяти, а не на диске.

DildoFagins · 22.06.2023

firon сказал(а):

Как обфусцировать *исходный код*?

Гугли компилятор Roslyn, там точно есть парсер и, если мне память не изменяет, были какие-то абстракции для AST трансформаций, может быть их можно встроить, как плагин к компилятору на этапе сборки проекта. Но в целом, мало кто станет делать обфускаторы исходников на С#, тк с MSIL тоже просто и удобно работать, есть готовые библиотеки типа AsmResolver, dnlib и Mono.Cecil.

firon сказал(а):

Вот если мой бинарник запускают из памяти, а не из диска, как мне тогда получить все байты моего бинарника?

С нативным кодом - это сложно, с дотнетами, если сборку грузили через Assembly.Load, то в ней даже секции обычно не настраиваются, она лежит в памяти, как и на диске. Берешь любой класс из свой сборки, получаешь его тип, у типа есть свойство модуль, у модуля вроде был hinstance, это и есть указатель на сборку в памяти.

firon · 29.06.2023

1) Вот свойства которые я добавил в .csproj

Код:

<IlcDebugType>none</IlcDebugType>
<IlcDebugSymbols>false</IlcDebugSymbols>
<IlcDebuggerSupport>false</IlcDebuggerSupport>
<IlcDebugInfo>false</IlcDebugInfo>
<IlcDebugInfoType>None</IlcDebugInfoType>
<IlcArgs>/noilcdebug</IlcArgs>
<Args>/nodebug</Args>
<NativeLinkerArguments>--strip-debug</NativeLinkerArguments>

Скомпилированный бинарник все равно содержит debug иформацию. Как мне её от туда полностью убрать?

2) В своей программе я использую параллелизм Parallel, но при каждом запуске программы она отрабатывает разное количесво времени, хотя данные и их объем одни и те же. Причем при первом запуске процесс может занять 10 секунд, а при втором 40-50 секунд. Я считаю такое поведение ненормальным. Мне кажется это по тому что стандартный балансировщик не учитывает особенности обрабатываемых объектов. Может случиться такое, что и первому и второму потоку выделится по 8 объектов на обработку. Но объекты, которые выделены на обработку первому потоку в десятки раз больше в объеме, чем объекты выделеные на обработку второму потоку. С точки зрения параллелизма работа вроде распределенна равномерно (и там и там по 8 объектов), а по факту (по объёму) все совсем не так. Я пытался использовать partitioner без буфферинга (EnumerablePartitionerOptions.NoBuffering), но это не решило проблему того, что при каждом запуске время работы может сильно отличаться. Ограничение числа потоков дало только негативный эффект. Если я напишу кастомный dynamic partitioner, это может исправить проблему? Или как ёё исправить?

Burnbrighter · 30.06.2023

Если память мне не изменяет то в TPL балансировка загрузки выполняется с помощью Task scheduler - планировщика задач. По умолчанию используется стандартный, но ты можешь реализовать свой собственный с блекджеком

V1rtualGh0st · 30.06.2023

firon сказал(а):
1) Вот свойства которые я добавил в .csproj
Код:
<IlcDebugType>none</IlcDebugType>
<IlcDebugSymbols>false</IlcDebugSymbols>
<IlcDebuggerSupport>false</IlcDebuggerSupport>
<IlcDebugInfo>false</IlcDebugInfo>
<IlcDebugInfoType>None</IlcDebugInfoType>
<IlcArgs>/noilcdebug</IlcArgs>
<Args>/nodebug</Args>
<NativeLinkerArguments>--strip-debug</NativeLinkerArguments>
Скомпилированный бинарник все равно содержит debug иформацию. Как мне её от туда полностью убрать?

2) В своей программе я использую параллелизм Parallel, но при каждом запуске программы она отрабатывает разное количесво времени, хотя данные и их объем одни и те же. Причем при первом запуске процесс может занять 10 секунд, а при втором 40-50 секунд. Я считаю такое поведение ненормальным. Мне кажется это по тому что стандартный балансировщик не учитывает особенности обрабатываемых объектов. Может случиться такое, что и первому и второму потоку выделится по 8 объектов на обработку. Но объекты, которые выделены на обработку первому потоку в десятки раз больше в объеме, чем объекты выделеные на обработку второму потоку. С точки зрения параллелизма работа вроде распределенна равномерно (и там и там по 8 объектов), а по факту (по объёму) все совсем не так. Я пытался использовать partitioner без буфферинга (EnumerablePartitionerOptions.NoBuffering), но это не решило проблему того, что при каждом запуске время работы может сильно отличаться. Ограничение числа потоков дало только негативный эффект. Если я напишу кастомный dynamic partitioner, это может исправить проблему? Или как ёё исправить?

XML:

<DebugType>none</DebugType>
<DebugSymbols>false</DebugSymbols>

добавь это и удали строки связанные с ilc (IlcDebugType, IlcDebugSymbols и тд)

firon · 30.06.2023

V1rtualGh0st сказал(а):

добавь это и удали

Я пробовал это в самом начале. Это не работает, поэтому я и имею весь этот геморой с дебагом

r3xq1 · 01.07.2023

firon сказал(а):

Это не работает

Ну вообще то работает.
Всё правильно написали, достаточно просто

XML:

<DebugType>none</DebugType>

впиши между

XML:

<PropertyGroup>
 <DebugType>none</DebugType>
</PropertyGroup>

И после компиляции никаких файлов с debug нету.

firon · 02.07.2023

r3xq1 сказал(а):

И после компиляции никаких файлов с debug нету.

У меня прям в самом бинарнике строка с полным путем к файлу .pdb (Диск\имя_пользователя\название_проекта\Release\файл.pdb) и ещё куча мест (в самом бинарнике) которые содержат оригинальное название проекта

Burnbrighter · 02.07.2023

Есть другие варианты:
- Можно удалить отладочную информацию с помощью mono.cecil, прям в бинарнике

- использовать обфускатор, который умеет в удаление отладочной информации

Kernel32dll · 16.08.2023

r3xq1 · 17.08.2023

Kernel32dll сказал(а):

есть ли возможность установки иконки во время компиляции исполняемого файла из исходного кода с помощью Roslyn?

https://stackoverflow.com/questions/41111826/emit-win32icon-with-roslyn

Kernel32dll сказал(а):

то добавляет ли сигнатур использование Resource Hacker на готовый ехешник?

А ты попробуй и узнаешь)

Kernel32dll сказал(а):

Или может есть вариант установки иконки с помощью Dnlib, Mono.cecil?

Они не поддерживают установки иконки на приложение, просто заменить иконки через ресурсы позволяют, но вот, чтобы установить - нет.
Можешь воспользоваться данным классом, который позволяет изменить иконку приложения:

C#:

using System;
    using System.Runtime.InteropServices;

    public static class Structures
    {
        [StructLayout(LayoutKind.Sequential)]
        public partial struct ICONDIR
        {
            public ushort Reserved;
            public ushort Type;
            public ushort Count;
        }

        [StructLayout(LayoutKind.Sequential)]
        public partial struct ICONDIRENTRY
        {
            public byte Width;
            public byte Height;
            public byte ColorCount;
            public byte Reserved;
            public ushort Planes;
            public ushort BitCount;
            public int BytesInRes;
            public int ImageOffset;
        }

        /// <summary>
        /// A resource header.
        /// </summary>
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct RESOURCE_HEADER
        {
            /// <summary>
            /// Header length.
            /// </summary>
            public ushort wLength;
            /// <summary>
            /// Data length.
            /// </summary>
            public ushort wValueLength;
            /// <summary>
            /// Resource type.
            /// </summary>
            public ushort wType;

            /// <summary>
            /// A new resource header of a given length.
            /// </summary>
            /// <param name="valueLength"></param>
            public RESOURCE_HEADER(ushort valueLength)
            {
                wLength = 0;
                wValueLength = valueLength;
                wType = 0;
            }
        }

        /// <summary>
        /// Language and code page combinations.
        /// The low-order word of each DWORD must contain a Microsoft language identifier,
        /// and the high-order word must contain the IBM code page number.
        /// Either high-order or low-order word can be zero, indicating that the file is language
        /// or code page independent.
        /// </summary>
        [StructLayout(LayoutKind.Sequential, CharSet = CharSet.Unicode)]
        public struct VAR_HEADER
        {
            /// <summary>
            /// Microsoft language identifier.
            /// </summary>
            public ushort wLanguageIDMS;
            /// <summary>
            /// IBM code page number.
            /// </summary>
            public ushort wCodePageIBM;
        }

        /// <summary>
        /// This structure contains version information about a file.
        /// This information is language- and code page–independent.
        /// http://msdn.microsoft.com/en-us/library/ms647001.aspx
        /// </summary>
        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        public struct VS_FIXEDFILEINFO
        {
            /// <summary>
            /// Contains the value 0xFEEF04BD. This is used with the szKey member of the VS_VERSIONINFO structure when searching a file for the VS_FIXEDFILEINFO structure.
            /// </summary>
            public uint dwSignature;
            /// <summary>
            /// Specifies the binary version number of this structure. The high-order word of this member contains the major version number, and the low-order word contains the minor version number.
            /// </summary>
            public uint dwStrucVersion;
            /// <summary>
            /// Specifies the most significant 32 bits of the file's binary version number. This member is used with dwFileVersionLS to form a 64-bit value used for numeric comparisons.
            /// </summary>
            public uint dwFileVersionMS;
            /// <summary>
            /// Specifies the least significant 32 bits of the file's binary version number. This member is used with dwFileVersionMS to form a 64-bit value used for numeric comparisons.
            /// </summary>
            public uint dwFileVersionLS;
            /// <summary>
            /// Specifies the most significant 32 bits of the binary version number of the product with which this file was distributed. This member is used with dwProductVersionLS to form a 64-bit value used for numeric comparisons.
            /// </summary>
            public uint dwProductVersionMS;
            /// <summary>
            /// Specifies the least significant 32 bits of the binary version number of the product with which this file was distributed. This member is used with dwProductVersionMS to form a 64-bit value used for numeric comparisons.
            /// </summary>
            public uint dwProductVersionLS;
            /// <summary>
            /// Contains a bitmask that specifies the valid bits in dwFileFlags. A bit is valid only if it was defined when the file was created.
            /// </summary>
            public uint dwFileFlagsMask;
            /// <summary>
            /// Contains a bitmask that specifies the Boolean attributes of the file.
            /// </summary>
            public uint dwFileFlags;
            /// <summary>
            /// Specifies the operating system for which this file was designed.
            /// </summary>
            public uint dwFileOS;
            /// <summary>
            /// Specifies the general type of file.
            /// </summary>
            public uint dwFileType;
            /// <summary>
            /// Specifies the function of the file.
            /// </summary>
            public uint dwFileSubtype;
            /// <summary>
            /// Specifies the most significant 32 bits of the file's 64-bit binary creation date and time stamp.
            /// </summary>
            public uint dwFileDateMS;
            /// <summary>
            /// Specifies the least significant 32 bits of the file's 64-bit binary creation date and time stamp.
            /// </summary>
            public uint dwFileDateLS;

            /// <summary>
            /// Creates a default Windows VS_FIXEDFILEINFO structure.
            /// </summary>
            /// <returns>A default Windows VS_FIXEDFILEINFO.</returns>
            public static VS_FIXEDFILEINFO GetWindowsDefault()
            {
                var fixedFileInfo = new VS_FIXEDFILEINFO
                {
                    dwSignature = NativeMethods.VS_FFI_SIGNATURE,
                    dwStrucVersion = NativeMethods.VS_FFI_STRUCVERSION,
                    dwFileFlagsMask = NativeMethods.VS_FFI_FILEFLAGSMASK,
                    dwFileOS = (uint)Enums.FileOs.VOS__WINDOWS32,
                    dwFileSubtype = (uint)Enums.FileSubType.VFT2_UNKNOWN,
                    dwFileType = (uint)Enums.FileType.VFT_DLL
                };
                return fixedFileInfo;
            }
        }

        /// <summary>
        /// A hardware-independent icon directory resource header.
        /// http://msdn.microsoft.com/en-us/library/ms997538.aspx
        /// </summary>
        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        public struct GRPICONDIR
        {
            /// <summary>
            /// Reserved, must be zero.
            /// </summary>
            public ushort wReserved;
            /// <summary>
            /// Resource type, 1 for icons.
            /// </summary>
            public ushort wType;
            /// <summary>
            /// Number of images.
            /// </summary>
            public ushort wImageCount;
        }

        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        public partial struct GRPICONDIRENTRY
        {
            public byte Width;
            public byte Height;
            public byte ColorCount;
            public byte Reserved;
            public ushort Planes;
            public ushort BitCount;
            public int BytesInRes;
            public ushort ID;
        }

        /// <summary>
        /// Hardware-independent icon directory entry in an .ico file.
        /// </summary>
        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        public struct FILEGRPICONDIRENTRY
        {
            /// <summary>
            /// Icon width.
            /// </summary>
            public byte bWidth;
            /// <summary>
            /// Icon height.
            /// </summary>
            public byte bHeight;
            /// <summary>
            /// Colors; 0 means 256 or more.
            /// </summary>
            public byte bColors;
            /// <summary>
            /// Reserved.
            /// </summary>
            public byte bReserved;
            /// <summary>
            /// Number of bitmap planes for icons.
            /// Horizontal hotspot for cursors.
            /// </summary>
            public ushort wPlanes;
            /// <summary>
            /// Bits per pixel for icons.
            /// Vertical hostpot for cursors.
            /// </summary>
            public ushort wBitsPerPixel;
            /// <summary>
            /// Image size in bytes.
            /// </summary>
            public uint dwImageSize;
            /// <summary>
            /// Offset of bitmap data from the beginning of the file.
            /// </summary>
            public uint dwFileOffset;
        }

        /// <summary>
        /// Hardware-independent icon structure in an .ico file.
        /// </summary>
        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        public struct FILEGRPICONDIR
        {
            /// <summary>
            /// Reserved, must be zero.
            /// </summary>
            public ushort wReserved;
            /// <summary>
            /// Resource Type (1 for icons).
            /// </summary>
            public ushort wType;
            /// <summary>
            /// Number of images.
            /// </summary>
            public ushort wCount;
        }

        /// <summary>
        /// Contains information about an icon or a cursor.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        internal struct ICONINFO
        {
            /// <summary>
            /// Specifies whether this structure defines an icon or a cursor.
            /// A value of TRUE specifies an icon; FALSE specifies a cursor.
            /// </summary>
            public bool IsIcon;
            /// <summary>
            /// Specifies the x-coordinate of a cursor's hot spot. If this structure defines an icon, the hot spot is
            /// always in the center of the icon, and this member is ignored.
            /// </summary>
            public int xHotspot;
            /// <summary>
            /// Specifies the y-coordinate of the cursor's hot spot. If this structure defines an icon, the hot spot
            /// is always in the center of the icon, and this member is ignored.
            /// </summary>
            public int yHotspot;
            /// <summary>
            /// Specifies the icon bitmask bitmap.
            /// </summary>
            public IntPtr MaskBitmap;
            /// <summary>
            /// Handle to the icon color bitmap.
            /// </summary>
            public IntPtr ColorBitmap;
        }

        [StructLayout(LayoutKind.Sequential)]
        public partial struct BITMAPINFOHEADER
        {
            public uint Size;
            public int Width;
            public int Height;
            public ushort Planes;
            public ushort BitCount;
            public uint Compression;
            public uint SizeImage;
            public int XPelsPerMeter;
            public int YPelsPerMeter;
            public uint ClrUsed;
            public uint ClrImportant;
        }

        /// <summary>
        /// Defines the dimensions and color information of a Windows-based device-independent bitmap (DIB).
        /// http://msdn.microsoft.com/en-us/library/dd183375(VS.85).aspx.
        /// </summary>
        [StructLayout(LayoutKind.Sequential)]
        public struct BITMAPINFO
        {
            /// <summary>
            /// Specifies a bitmap information header structure that contains information about the dimensions of color format.
            /// </summary>
            public BITMAPINFOHEADER bmiHeader;
            /// <summary>
            /// An array of RGBQUAD. The elements of the array make up the color table.
            /// </summary>
            public RGBQUAD bmiColors;
        }

        /// <summary>
        /// Store colors in a paletised icon (2, 4 or 8 bit).
        /// http://msdn.microsoft.com/en-us/library/ms997538.aspx
        /// </summary>
        [StructLayout(LayoutKind.Sequential, Pack = 1)]
        public struct RGBQUAD
        {
            /// <summary>
            /// Blue.
            /// </summary>
            public byte rgbBlue;
            /// <summary>
            /// Green.
            /// </summary>
            public byte rgbGreen;
            /// <summary>
            /// Red.
            /// </summary>
            public byte rgbRed;
            /// <summary>
            /// Reserved.
            /// </summary>
            public byte rgbReserved;
        }

        /// <summary>
        /// The BITMAPFILEHEADER structure contains information about the type, size, and layout of a file that contains a DIB.
        /// http://msdn.microsoft.com/en-us/library/dd183374(VS.85).aspx
        /// </summary>
        [StructLayout(LayoutKind.Sequential, Pack = 2)]
        public struct BITMAPFILEHEADER
        {
            /// <summary>
            /// The file type; must be BM.
            /// </summary>
            public ushort bfType;
            /// <summary>
            /// The size, in bytes, of the bitmap file.
            /// </summary>
            public uint bfSize;
            /// <summary>
            /// Reserved; must be zero.
            /// </summary>
            public ushort bfReserved1;
            /// <summary>
            /// Reserved; must be zero.
            /// </summary>
            public ushort bfReserved2;
            /// <summary>
            /// The offset, in bytes, from the beginning of the BITMAPFILEHEADER structure to the bitmap bits.
            /// </summary>
            public uint bfOffBits;
        }
    }

C#:

    using System;
    using System.IO;
    using System.Runtime.InteropServices;

    public class IconEditor
    {
        private Structures.ICONDIR iconDir = new Structures.ICONDIR();
        private Structures.ICONDIRENTRY[] iconEntry;
        private byte[][] iconImage;
        public int ImageCount => iconDir.Count;
        public byte[] Get_ImageData(int index) => iconImage[index];
        private const uint RT_ICON = 3, RT_GROUP_ICON = 14;

        public void InjectIcon(string exeFileName, string iconFileName, bool backup)
        {
            if (backup)
            {
                File.Copy(exeFileName, $"{exeFileName}.backup");
            }
            InjectIcon(exeFileName, iconFileName, 1, 1);
        }
        public void InjectIcon(string exeFileName, string iconFileName, uint iconGroupID, uint iconBaseID)
        {
            IconEditor iconFile = FromFile(iconFileName);
            IntPtr hUpdate = NativeMethods.BeginUpdateResource(exeFileName, false);
            byte[] data = iconFile.CreateIconGroupData(iconBaseID);
            NativeMethods.UpdateResource(hUpdate, new IntPtr(RT_GROUP_ICON), new IntPtr(iconGroupID), 0, data, data.Length);
            for (int i = 0, loopTo = iconFile.ImageCount - 1; i <= loopTo; i++)
            {
                byte[] image = iconFile.Get_ImageData(i);
                NativeMethods.UpdateResource(hUpdate, new IntPtr(RT_ICON), new IntPtr(iconBaseID + i), 0, image, image.Length);
            }
            NativeMethods.EndUpdateResource(hUpdate, false);
        }

        public IconEditor FromFile(string filename)
        {
            var instance = new IconEditor();
            try
            {
                byte[] fileBytes = File.ReadAllBytes(filename);
                //  var instance = new IconChanger().FromFile(filename);
                var pinnedBytes = GCHandle.Alloc(fileBytes, GCHandleType.Pinned);
                instance.iconDir = (Structures.ICONDIR)Marshal.PtrToStructure(pinnedBytes.AddrOfPinnedObject(), typeof(Structures.ICONDIR));
                instance.iconEntry = new Structures.ICONDIRENTRY[instance.iconDir.Count];
                instance.iconImage = new byte[instance.iconDir.Count][];
                int offset = Marshal.SizeOf(instance.iconDir);
                Type iconDirEntryType = typeof(Structures.ICONDIRENTRY);
                int size = Marshal.SizeOf(iconDirEntryType);
                for (int i = 0, loopTo = instance.iconDir.Count - 1; i <= loopTo; i++)
                {
                    var entry = (Structures.ICONDIRENTRY)Marshal.PtrToStructure(new IntPtr(pinnedBytes.AddrOfPinnedObject().ToInt64() + offset), iconDirEntryType);
                    instance.iconEntry[i] = entry;
                    instance.iconImage[i] = new byte[entry.BytesInRes];
                    Buffer.BlockCopy(fileBytes, entry.ImageOffset, instance.iconImage[i], 0, entry.BytesInRes);
                    offset += size;
                }

                pinnedBytes.Free();
            }
            catch { }
            return instance;
        }

        public byte[] CreateIconGroupData(uint iconBaseID)
        {
            try
            {
                int sizeOfIconGroupData = Marshal.SizeOf(typeof(Structures.ICONDIR)) + (Marshal.SizeOf(typeof(Structures.GRPICONDIRENTRY)) * ImageCount);
                var data = new byte[sizeOfIconGroupData];
                var pinnedData = GCHandle.Alloc(data, GCHandleType.Pinned);
                Marshal.StructureToPtr(iconDir, pinnedData.AddrOfPinnedObject(), false);
                int offset = Marshal.SizeOf(iconDir);
                for (int i = 0, loopTo = ImageCount - 1; i <= loopTo; i++)
                {
                    var grpEntry = new Structures.GRPICONDIRENTRY();
                    var bitmapheader = new Structures.BITMAPINFOHEADER();
                    var pinnedBitmapInfoHeader = GCHandle.Alloc(bitmapheader, GCHandleType.Pinned);
                    Marshal.Copy(Get_ImageData(i), 0, pinnedBitmapInfoHeader.AddrOfPinnedObject(), Marshal.SizeOf(typeof(Structures.BITMAPINFOHEADER)));
                    pinnedBitmapInfoHeader.Free();
                    grpEntry.Width = iconEntry[i].Width;
                    grpEntry.Height = iconEntry[i].Height;
                    grpEntry.ColorCount = iconEntry[i].ColorCount;
                    grpEntry.Reserved = iconEntry[i].Reserved;
                    grpEntry.Planes = bitmapheader.Planes;
                    grpEntry.BitCount = bitmapheader.BitCount;
                    grpEntry.BytesInRes = iconEntry[i].BytesInRes;
                    var result = unchecked((ushort)(iconBaseID + i));
                    grpEntry.ID = result;
                    Marshal.StructureToPtr(grpEntry, new IntPtr(pinnedData.AddrOfPinnedObject().ToInt64() + offset), false);
                    offset += Marshal.SizeOf(typeof(Structures.GRPICONDIRENTRY));
                }

                pinnedData.Free();
                return data;
            }
            catch { return null; }
        }
    }

C#:

IconEditor icon = new();
icon.InjectIcon("Путь к .exe файлу", Path.GetFullPath("путь к иконке"), false); // true - делаем бэкап | false - нет.

Kernel32dll · 18.08.2023

firon · 09.10.2023

Как избавиться от ошибки "Ненайдена API-MS-WIN-CRT-Heap-L1-1-0.dll" (возникает на старых машинах от 2012 года и старше). Можно эту dll-ку както статически прилинковать?

f3ntdev · 04.02.2024

пытаюсь подставлять auth-token который передается при загрузке страницы, следующим способом:

Код:

string[] tokens = File.ReadAllLines("tokens.txt");
// выбор рандомного токена
string randomToken = tokens[random.Next(tokens.Length)];

await page.SetCookieAsync(new CookieParam
                        {
                            Name = "auth-token",
                            Value = randomToken,
                            Domain = "player.twitch.tv",
                            Path = "/", 
                            HttpOnly = false, 
                            Secure = false 
                        });

                        // Переход на URL и ожидание готовности
                        await page.GoToAsync(url, timeout: Config.timeout * 1000, waitUntil: waitUntil);

но в итоге бесконечная загрузка страницы и по итогу ломается(страничка тупо не догружается) хелпаните пж

belogwardeets · 08.02.2024

f3ntdev сказал(а):
пытаюсь подставлять auth-token который передается при загрузке страницы, следующим способом:
Посмотреть вложение 76128
Код:
string[] tokens = File.ReadAllLines("tokens.txt");
// выбор рандомного токена
string randomToken = tokens[random.Next(tokens.Length)];

await page.SetCookieAsync(new CookieParam
                        {
                            Name = "auth-token",
                            Value = randomToken,
                            Domain = "player.twitch.tv",
                            Path = "/",
                            HttpOnly = false,
                            Secure = false
                        });

                        // Переход на URL и ожидание готовности
                        await page.GoToAsync(url, timeout: Config.timeout * 1000, waitUntil: waitUntil);
но в итоге бесконечная загрузка страницы и по итогу ломается(страничка тупо не догружается) хелпаните

Скорее всего, не получается из-за несоответствия токена с другими куки

n0sf1ratu · 14.02.2024

f3ntdev сказал(а):

Код:

string[] tokens = File.ReadAllLines("tokens.txt");
// выбор рандомного токена
string randomToken = tokens[random.Next(tokens.Length)];

await page.SetCookieAsync(new CookieParam
                        {
                            Name = "auth-token",
                            Value = randomToken,
                            Domain = "player.twitch.tv",
                            Path = "/",
                            HttpOnly = false,
                            Secure = false
                        });

                        // Переход на URL и ожидание готовности
                        await page.GoToAsync(url, timeout: Config.timeout * 1000, waitUntil: waitUntil);

но в итоге бесконечная загрузка страницы и по итогу ломается(страничка тупо не догружается) хелпаните пж

Салют, поясни пожалуйста timeout: Config.timeout * 1000

belogwardeets · 21.03.2024

n0sf1ratu сказал(а):

Салют, поясни пожалуйста timeout: Config.timeout * 1000

Скорее всего дело в следующем: время в конфиге указывается в секундах, а метод GoToAsync принимает миллисекунды, соответственно секунды переводят в миллисекунды умножением на 1000
А так без контекста сложно понять... Что за библиотека? Откуда метод и тд

Вопросы по С#

RAID-массив

CD-диск

HDD-drive

RAID-массив

TPU unit

RAID-массив

HDD-drive

(L3) cache

RAID-массив

(L3) cache

RAID-массив

HDD-drive

(L3) cache

(L3) cache

(L3) cache

RAID-массив

floppy-диск

HDD-drive

RAID-массив

HDD-drive