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;
}

<html><body>
 
<form name="Poll" action="vote.php" method="post">
 
<input type="hidden" name="param1" value="param 1 value" />
<input type="hidden" name="param2" value="param 2 value" />
<input type="hidden" name="param3" value="param 3 value" />
 
<input type="submit" value="Submit" />
 
</form>
 
</body></html>

<?php
 
$url = 'http://www.example.com/vote.php';
 
// lista przegladarek
$agents = array("Mozilla/4.0 (compatible; MSIE 7.0; Windows NT 6.0; WOW64; SLCC1; .NET CLR 2.0.50727; .NET CLR 3.0.04506; Media Center PC 5.0)",
                "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.0)",
                "Opera/9.63 (Windows NT 6.0; U; ru) Presto/2.1.1",
                "Mozilla/5.0 (Windows; U; Windows NT 6.0; en-US; rv:1.9.0.5) Gecko/2008120122 Firefox/3.0.5",
                "Mozilla/5.0 (X11; U; Linux i686 (x86_64); en-US; rv:1.8.1.18) Gecko/20081203 Firefox/2.0.0.18",
                "Mozilla/5.0 (Windows; U; Windows NT 5.1; en-US; rv:1.8.1.16) Gecko/20080702 Firefox/2.0.0.16",
                "Mozilla/5.0 (Macintosh; U; Intel Mac OS X 10_5_6; en-us) AppleWebKit/525.27.1 (KHTML, like Gecko) Version/3.2.1 Safari/525.27.1"
                );
 
$ch = curl_init();
 
// parametry
$fields = array('param1' => urlencode('param 1 value'),
                'param2' => urlencode('param 2 value'),
                'param3' => urlencode('param 3 value'),
                'submit' => urlencode('Submit vote')
        );
 
// zbuduj poprawny ciag dla cURL
foreach($fields as $key => $value)
{
        $fields_string .= $key.'='.$value.'&';
}
 
rtrim($fields_string, '&');
 
$ch = curl_init();
 
// adres strony
curl_setopt($ch, CURLOPT_URL, $url);
 
// ilosc parametrow
curl_setopt($ch, CURLOPT_POST, count($fields));
 
// parametry POST
curl_setopt($ch, CURLOPT_POSTFIELDS, $fields_string);
 
// przegladarka
curl_setopt($ch, CURLOPT_USERAGENT, array_rand($agents));
 
// zwroc tylko wynik
curl_setopt($ch, CURLOPT_RETURNTRANSFER, true);
 
$result = curl_exec($ch);
 
curl_close($ch);
 
// wyswietl wynikowy kod html
//echo $result;
 
?>

sbb edx, edx ; part of step 2. - edx = 0xffffff if CF=1, 0x000000 otherwise
mov ecx, eax
xor ecx, ebx ; step 1
and ecx, edx ; completed step 2. - now C is 0 or (A xor B)
xor eax, ecx ; step 3
xor ebx, ecx ; step 4