using System;
using System.IO;
using System.Collections.Generic;
using System.Text;
 
namespace NetPatcher
{
    class Patcher
    {
        public FileStream inputFile;
 
        public Patcher()
        {
        }
 
        ~Patcher()
        {
            CloseFile();
        }
 
        public bool OpenFile(string filePath)
        {
            try
            {
                inputFile = new FileStream(filePath, FileMode.Open, FileAccess.ReadWrite);
 
                return inputFile == null ? false : true;
            }
            catch (Exception e)
            {
                //return false;
            }
 
            return false;
        }
 
        public void CloseFile()
        {
            if (inputFile != null)
            {
                inputFile.Close();
            }
 
            inputFile = null;
        }
 
        public long PatchArray(long fileOffset, byte[] patchBytes)
        {
            inputFile.Seek(fileOffset, SeekOrigin.Begin);
            inputFile.Write(patchBytes, 0, patchBytes.Length);
 
            return inputFile.Position;
        }
 
        public long PatchByte(long fileOffset, byte patchByte)
        {
            inputFile.Seek(fileOffset, SeekOrigin.Begin);
            inputFile.WriteByte(patchByte);
 
            return inputFile.Position;
        }
 
        public long PatchString(long fileOffset, string patchString)
        {
            System.Text.Encoding asciiEncoding = System.Text.Encoding.ASCII;
            byte[] encodedPatchString = asciiEncoding.GetBytes(patchString);
 
            return PatchArray(fileOffset, encodedPatchString);
        }
 
        public long PatchDelphiString(long fileOffset, string patchString)
        {
            System.Text.Encoding asciiEncoding = System.Text.Encoding.GetEncoding(1250);
 
            byte[] encodedPatchString = asciiEncoding.GetBytes(patchString);
 
            PatchByte(fileOffset, (byte)encodedPatchString.Length);
            PatchArray(fileOffset + 1, encodedPatchString);
 
            return inputFile.Position;
        }
 
        public long PatchInt32(long fileOffset, Int32 patchInt32)
        {
            byte[] encodedInt32 = BitConverter.GetBytes(patchInt32);
            PatchArray(fileOffset, encodedInt32);
 
            return inputFile.Position;
        }
 
        public long PatchFill(long fileOffset, long Length, byte patchByteFill)
        {
            while (Length-- != 0)
            {
                PatchByte(fileOffset++, patchByteFill);
            }
 
            return inputFile.Position;
        }
 
    }
}

using System;
using System.Runtime.InteropServices;
 
// potrzebne importy
[DllImport("KERNEL32.dll", SetLastError=true)]
static extern IntPtr OpenEvent(uint dwDesiredAccess, bool bInheritHandle, string lpName);
 
[DllImport("KERNEL32.dll", SetLastError=true)]
static extern IntPtr CreateMutex(IntPtr lpMutexAttributes, bool bInitialOwner, string lpName);
 
[DllImport("KERNEL32.dll")]
private extern static Boolean CloseHandle(IntPtr handle);
 
public const int ERROR_ALREADY_EXISTS = 183;
 
/// <summary>
/// wykrywanie obecności VMWare po zainstalowanych narzędziach VMWare Tools
/// na wirtualnej maszynie
/// </summary>
/// <returns>true jeśli wykryto zainstalowane narzędzia VMWare Tools</returns>
public static bool IsVMWare()
{
    // otwórz obiekt "VMwareDnDManagerEvent"
    IntPtr eventHandle = OpenEvent(0x001F0003, false, "VMwareDnDManagerEvent");
 
    // jeśli udało się otworzyć event, to znaczy, że obecne są narzędzia VMWare Tools
    if (eventHandle != IntPtr.Zero)
    {
        CloseHandle(eventHandle);
        return true;
    }
 
    // utwórz mutex o nazwie wykorzystywanej przez VMWare Tools
    IntPtr mutexHandle = CreateMutex(IntPtr.Zero, false, "VMwareGuestDnDDataMutex");
 
    // zamknij uchwyt mutexa
    if (mutexHandle != IntPtr.Zero)
    {
        CloseHandle(mutexHandle);
    }
 
    // jeśli mutex o tej nazwie istnieje, to znaczy, że są obecne narzędzia VMware Tools
    if (Marshal.GetLastWin32Error() == ERROR_ALREADY_EXISTS)
    {
        return true;
    }
 
    return false;
}

using System.Management;
using System.Security.Cryptography;
 
/// <summary>
/// pobiera sprzętowy identyfikator maszyny korzystając z interfejsu WMI
/// </summary>
/// <returns>identyfikator sprzętowy w formie hasha SHA1</returns>
public static String hardwareId()
{
    // tymczasowy string
    String tempString = "";
 
    // "baza danych", z której pobieramy informacje o systemie
    String wmiScope = @"root\CIMV2";
 
    // tabela zapytań WMI i pobieranych elementów
    String[,] wmiQueries = new String[,]
    {
        { "SELECT ProcessorId FROM Win32_Processor", "ProcessorId" },
        { "SELECT Caption FROM Win32_Processor", "Caption" },
        { "SELECT Manufacturer FROM Win32_Processor", "Manufacturer" },
        { "SELECT Caption FROM Win32_BIOS", "Caption" }
    };
 
    // wywołujemy kolejne zapytania WMI
    for (int i = 0; i < wmiQueries.GetLength(0); i++)
    {
        try
        {
            // wykonaj zapytanie WMI
            ManagementObjectSearcher searcher = new ManagementObjectSearcher(wmiScope, wmiQueries[i, 0]);
 
            // zbuduj string z kolejnymi elementami odpowiedzi po zapytaniach WMI
            foreach (ManagementObject obj in searcher.Get())
            {
                tempString += obj[wmiQueries[i, 1]].ToString();
            }
        }
        catch (ManagementException exception)
        {
            // loguj błąd odczytu danych z WMI
        }
    }
 
    // generuj hash SHA1 ze wszystkich zebranych danych WMI
    SHA1 hash = SHA1CryptoServiceProvider.Create();
 
    // ciąg znaków zamień na tablicę bajtów
    byte[] plainTextBytes = Encoding.ASCII.GetBytes(tempString);
 
    // oblicz hash SHA1
    byte[] hashBytes = hash.ComputeHash(plainTextBytes);
 
    // konwertuj hash SHA1 na postać tekstową (i usuń zbędne znaki "-")
    tempString = BitConverter.ToString(hashBytes).Replace("-", "");
 
    return tempString;
}