C++ ve PHP kullanarak hwid lisans sistemi için basit kodlama ve bazı güvenlik önlemleri hakkında bilgi!

testerhdre' Alıntı:

Good job and thank you for sharing, using inline assembly (__asm) which is specific to certain compilers and architectures.if you intend to compile and run this code on a different architecture, such as ARM or PowerPC, i tried to replace the inline assembly code with platform-independent code using the CPUID instruction provided by the intrinsics library
my try :

C++:

#include <iostream>
#include <string>
#include <intrin.h>
#include <Windows.h>

// function to get HWID
std::string GetHWID()
{
    std::string hwid;

    // CPU ID
    int cpuInfo[4] = { 0 };
    __cpuid(cpuInfo, 1);

    char cpuID[16];
    memcpy(cpuID, &cpuInfo[1], sizeof(cpuID));
    hwid += cpuID;

    // Adding other components to the HWID (MAC address, hardware ID, Windows key, BIOS ID, SSD ID, etc.)

    return hwid;
}

int main()
{
    std::string hwid = GetHWID();

    // The process of sending the HWID to the API
    // Here you can make a GET request and communicate with the PHP API endpoint

    return 0;
}

Genişletmek için tıklayın ...

MAMUN09' Alıntı:

To create a simple HWID (Hardware ID) license system using C++ and PHP, you'll need to implement the following steps:

1. C++ Implementation:
   • Write a C++ program to retrieve the HWID of the user's machine. You can use system-specific libraries or APIs to obtain the HWID. This identifier should be unique to each user's hardware configuration.
   • Generate a license key based on the obtained HWID. You can use cryptographic algorithms like SHA-256 or MD5 to hash the HWID and generate a unique license key.
   • Provide a user interface to enter the license key and validate it against the generated HWID. If the entered license key matches the HWID, grant access to the software.
2. PHP Implementation:
   • Create a PHP script that receives the entered license key from the C++ program.
   • Store the generated license keys along with their corresponding HWIDs in a database or a file.
   • Compare the entered license key with the stored license keys. If there is a match, send a success response to the C++ program; otherwise, send an error response.

Security Measures: To enhance the security of your HWID license system, consider implementing the following measures:

1. Obfuscation and Encryption:
   • Obfuscate your C++ code to make it harder for reverse engineering attempts. Tools like UPX or Themida can be used for this purpose.
   • Encrypt the license keys stored in your database or file to protect them from unauthorized access. Use strong encryption algorithms like AES or RSA.
2. License Key Generation:
   • Use a secure random number generator or cryptographic library to generate license keys. Avoid using predictable patterns that can be easily guessed.
   • Incorporate a salt or secret key in the license key generation process to add an additional layer of security.
3. Communication Security:
   • When transmitting license key data between the C++ program and PHP script, ensure secure communication channels. Use HTTPS with SSL/TLS encryption to protect data during transmission.
4. Server-Side Validation:
   • Implement server-side validation in the PHP script to prevent tampering or spoofing attempts. Verify the legitimacy of the license key and HWID before granting access.
5. License Revocation and Renewal:
   • Implement a mechanism to revoke and block license keys if they are compromised or misused. Provide a way to renew licenses for legitimate users.
6. Regular Updates:
   • Keep your license system up to date with security patches and bug fixes to address any potential vulnerabilities.

Remember that while these measures can enhance the security of your HWID license system, determined attackers may still find ways to circumvent the system. It's important to strike a balance between security measures and usability to provide a smooth user experience.

Genişletmek için tıklayın ...

ByYasin' Alıntı:

C++ ve PHP dillerini kullanarak bir HWID lisans sistemi kodlarını paylaşabilirim. Ancak, kodların tamamını burada paylaşmak zor olabilir, çünkü oldukça detaylı bir konu ve kod miktarı fazla olabilir. Bunun yerine, size örnek bir çerçeve sunabilirim ve ihtiyaçlarınıza göre uyarlamalar yapabilirsiniz. Ayrıca, bazı güvenlik önlemlerini ve API'yi şifreleme ile ilgili detayları içeren açıklamaları da verebilirim.

Öncelikle, PHP tarafındaki PDO kullanarak HWID lisans sistemi kodlarını aşağıda bulabilirsiniz:

PHP:

<?php
// Veritabanı bağlantısı
$host = "localhost";
$dbname = "your_database_name";
$username = "your_username";
$password = "your_password";
$options = array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8');

try {
    $db = new PDO("mysql:host=$host;dbname=$dbname", $username, $password, $options);
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch(PDOException $e) {
    die("Veritabanı bağlantısı başarısız oldu: " . $e->getMessage());
}

// Lisansı kontrol etmek için API endpoint'i
if(isset($_GET['hwid'])) {
    $hwid = $_GET['hwid'];
 
    // API'ye gönderilen verileri şifreleme
    // Örneğin, burada hash işlemi yapabilirsiniz
    // $hwid = hash('sha256', $hwid);
 
    try {
        // Lisansı veritabanında kontrol etme
        $stmt = $db->prepare("SELECT * FROM licenses WHERE hwid = :hwid AND expiry_date > NOW() LIMIT 1");
        $stmt->bindParam(':hwid', $hwid);
        $stmt->execute();
        $result = $stmt->fetch(PDO::FETCH_ASSOC);
    
        if($result) {
            // Lisans geçerli
            echo "Lisans geçerli.";
        } else {
            // Lisans geçersiz
            echo "Lisans geçersiz.";
        }
    } catch(PDOException $e) {
        echo "Hata: " . $e->getMessage();
    }
}
?>

Yukarıdaki PHP kodu, GET isteği ile hwid parametresini alır ve bu HWID'nin veritabanında geçerli bir lisans olup olmadığını kontrol eder. Bu noktada, veritabanı bağlantısı ve lisans tablosunun yapısını uygun şekilde ayarlamanız gerekmektedir.

C++ tarafında, HWID lisans sistemiyle ilgili örnek bir kod aşağıda verilmiştir:

C++:

#include <iostream>
#include <string>
#include <Windows.h>

// HWID'yi alma fonksiyonu
std::string GetHWID()
{
    std::string hwid;

    // CPU ID
    char cpuID[1024];
    DWORD bufSize = sizeof(cpuID);
    __asm
    {
        push eax
        push ebx
        push ecx
        push edx

        mov eax, 1
        cpuid
        mov ebx, cpuID
        mov[ebx], eax
        mov[eax + 4], ebx
        mov[eax + 8], ecx
        mov[eax + 12], edx

        pop edx
        pop ecx
        pop ebx
        pop eax
    }

    hwid += cpuID;

    // Diğer bileşenlerin HWID'ye eklenmesi (MAC adresi, hardware ID, Windows key, BIOS ID, SSD ID, vb.)

    return hwid;
}

int main()
{
    std::string hwid = GetHWID();

    // HWID'yi API'ye gönderme işlemi
    // Burada GET isteği yapabilir ve PHP API endpoint'iyle iletişim kurabilirsiniz

    return 0;
}

Yukarıdaki C++ kodu, HWID'yi alma işlevini sağlar ve bu HWID'yi PHP tarafındaki API'ye göndermek için kullanabilirsiniz. Bu koddaki diğer bileşenlerin HWID'ye eklenmesi işlemlerini gerçekleştirmeniz gerekmektedir (MAC adresi, hardware ID, Windows key, BIOS ID, SSD ID, vb.).

Güvenlik önlemleri için, HTTPS protokolünü kullanmanızı ve API'ye veri gönderirken şifreleme yöntemlerini (örn. SSL/TLS) kullanmanızı öneririm. Bunlar, verilerin güvenli bir şekilde iletilmesini sağlar.

Ayrıca, lisansın başlangıç ve bitiş tarihlerini takip etmek için bir veritabanı tablosu veya başka bir yöntem kullanmanız gerekebilir. Süresi dolan lisanslara erişimi engellemek için, PHP kodunda "expiry_date" alanını kontrol etmekteyiz ve geçerli tarihten önceki lisansları reddetmekteyiz.

Unutmayın, veritabanı tablolarını ve diğer kod kısımlarını kendi ihtiyaçlarınıza göre uyarlamalısınız. Ayrıca, güvenlik konularında dikkatli olmanız ve ihtiyaçlarınıza göre ek güvenlik önlemleri eklemeniz önemlidir. Bu sadece bir örnek çerçeve olduğu için, tam bir güvenlik çözümü sağlamayabilir.
Aşağıda veritabanı bağlantısı ve lisans tablosunun yapısını gösteren bir örnek kod vereceğim. Ayrıca, diğer bileşenlerin HWID'ye eklenmesi işlemlerini ve lisansın başlangıç ve bitiş tarihlerini takip etme ve süresi dolan lisanslara erişimi engelleme kodlarını da ekleyeceğim.

MySQL veritabanı bağlantısı ve lisans tablosu yapısı:

PHP:

<?php
$host = "localhost";
$dbname = "your_database_name";
$username = "your_username";
$password = "your_password";
$options = array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8');

try {
    $db = new PDO("mysql:host=$host;dbname=$dbname", $username, $password, $options);
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch(PDOException $e) {
    die("Veritabanı bağlantısı başarısız oldu: " . $e->getMessage());
}

// Lisans tablosunun oluşturulması
try {
    $db->exec("CREATE TABLE IF NOT EXISTS licenses (
        id INT(11) AUTO_INCREMENT PRIMARY KEY,
        hwid VARCHAR(255) NOT NULL,
        expiry_date DATETIME NOT NULL
    )");
} catch(PDOException $e) {
    die("Lisans tablosu oluşturulamadı: " . $e->getMessage());
}
?>

Yukarıdaki PHP kodu, veritabanı bağlantısını gerçekleştirir ve licenses adında bir tablo oluşturur. Bu tablo, lisansları ve bunların geçerlilik sürelerini tutmak için kullanılır.

Diğer bileşenlerin HWID'ye eklenmesi işlemlerini gerçekleştirmek için, HWID'yi alırken ilgili bileşenlerin değerlerini toplamanız gerekmektedir. Örneğin, MAC adresini almak için exec() fonksiyonunu kullanabilirsiniz:

PHP:

<?php
// MAC adresini alma fonksiyonu
function GetMacAddress()
{
    $macAddr = false;
    $arp = `arp -a`;
    $lines = explode("\n", $arp);

    foreach($lines as $line) {
        $cols = preg_split('/\s+/', trim($line));

        if(isset($cols[1]) && $cols[1] == "(Interface)") {
            $macAddr = $cols[2];
            break;
        }
    }

    return $macAddr;
}

$macAddress = GetMacAddress();
?>

Bu örnekte, arp -a komutu kullanarak MAC adresini alıyoruz. Diğer bileşenlerin değerlerini de benzer şekilde alabilir ve HWID'ye ekleyebilirsiniz.

Lisansın başlangıç ve bitiş tarihlerini takip etmek için, expiry_date adında bir sütun oluşturduk. Lisansın süresini ayarladıktan sonra, bu tarihle ilgili karşılaştırmaları yaparak lisansın geçerli olup olmadığını kontrol edebilirsiniz. Örneğin, API kodunda aşağıdaki gibi bir kontrol yapabilirsiniz:

PHP:

<?php
// Lisansı kontrol etmek için API endpoint'i
if(isset($_GET['hwid'])) {
    $hwid = $_GET['hwid'];
 
    // API'ye gönderilen verileri şifreleme
    // Örneğin, burada hash işlemi yapabilirsiniz
    // $hwid = hash('sha256', $hwid);
 
    try {
        // Lisansı veritabanında kontrol etme
        $stmt = $db->prepare("SELECT * FROM licenses WHERE hwid = :hwid AND expiry_date > NOW() LIMIT 1");
        $stmt->bindParam(':hwid', $hwid);
        $stmt->execute();
        $result = $stmt->fetch(PDO::FETCH_ASSOC);
    
        if($result) {
            // Lisans geçerli
            echo "Lisans geçerli.";
        } else {
            // Lisans geçersiz
            echo "Lisans geçersiz.";
        }
    } catch(PDOException $e) {
        echo "Hata: " . $e->getMessage();
    }
}
?>

Yukarıdaki kod, expiry_date > NOW() kontrolüyle lisansın geçerli olup olmadığını kontrol eder. Lisansın başlangıç ve bitiş tarihlerini uygun şekilde ayarlamalısınız.

Bu örnekler, veritabanı bağlantısı, lisans tablosu yapısı, diğer bileşenlerin HWID'ye eklenmesi ve lisansın başlangıç ve bitiş tarihlerinin takip edilmesi için size bir temel sağlar. Kodları ihtiyaçlarınıza göre uyarlayabilir ve ek güvenlik önlemleri ekleyebilirsiniz. Güvenlik açısından SSL/TLS kullanımını öneririm ve API verilerini doğru bir şekilde şifreleyerek güvenliği artırabilirsiniz.

SSL/TLS kullanımını ve API verilerini doğru bir şekilde şifreleyerek güvenliği artırmak için örnek bir kod verebilirim. Aşağıdaki örnekte, PHP tarafında HTTPS protokolünü kullanarak güvenli bir bağlantı kuracağız ve API verilerini şifreleyeceğiz:

PHP:

<?php
// Veritabanı bağlantısı
$host = "localhost";
$dbname = "your_database_name";
$username = "your_username";
$password = "your_password";
$options = array(PDO::MYSQL_ATTR_INIT_COMMAND => 'SET NAMES utf8');

try {
    $db = new PDO("mysql:host=$host;dbname=$dbname", $username, $password, $options);
    $db->setAttribute(PDO::ATTR_ERRMODE, PDO::ERRMODE_EXCEPTION);
} catch(PDOException $e) {
    die("Veritabanı bağlantısı başarısız oldu: " . $e->getMessage());
}

// Lisansı kontrol etmek için API endpoint'i
if(isset($_GET['hwid'])) {
    $hwid = $_GET['hwid'];
 
    // API'ye gönderilen verileri şifreleme
    // Örneğin, burada SSL/TLS kullanabilirsiniz
    // ve verileri şifreleyip çözmek için openssl_encrypt() ve openssl_decrypt() işlevlerini kullanabilirsiniz

    // SSL/TLS kullanarak güvenli bağlantı oluşturma
    $contextOptions = array(
        'ssl' => array(
            'verify_peer' => false, // SSL sertifikasını kontrol etme
            'verify_peer_name' => false, // SSL sertifikasının ismini kontrol etme
        ),
    );
    $context = stream_context_create($contextOptions);

    $url = 'https://your-domain.com/your-api-endpoint.php?hwid=' . urlencode($hwid);
    $response = file_get_contents($url, false, $context);

    if($response !== false) {
        // API yanıtını çözme
        // Örneğin, burada openssl_decrypt() işlevini kullanabilirsiniz

        echo "API yanıtı: " . $response;
    } else {
        echo "API isteği başarısız oldu.";
    }
}
?>

Yukarıdaki kodda, HTTPS protokolünü kullanarak güvenli bir bağlantı oluşturmak için stream_context_create() fonksiyonunu ve $contextOptions değişkenini kullanıyoruz. Bu, sunucu ile güvenli bir şekilde iletişim kurmamızı sağlar. file_get_contents() fonksiyonunu kullanarak API endpoint'ine HTTPS üzerinden istek yapıyoruz.

Verileri şifrelemek için openssl_encrypt() fonksiyonunu kullanabilir ve verileri çözmek için openssl_decrypt() fonksiyonunu kullanabilirsiniz. Bu fonksiyonları kullanarak, API verilerini şifreleyebilir ve çözebilirsiniz. Şifreleme ve çözme işlemleri için uygun anahtarlar ve algoritma parametrelerini ayarlamanız gerekmektedir.

Bu örnekte, SSL/TLS kullanımı ve API verilerinin şifrelenmesiyle güvenliği artırabilirsiniz. Ancak, gerçek uygulamada daha kapsamlı güvenlik önlemleri almanız ve güvenlik gereksinimlerinize göre kodları uyarlamak önemlidir.

Php kodlarında bukadar detaylı yazmamın sebebi karşılaştırma yapmanızın daha kolay olması için.

Aşağıda C++ dilinde diğer bileşenlerin HWID'ye eklenmesi ve HWID'nin API'ye gönderilmesi için bir örnek kod vereceğim:

C++:

#include <iostream>

#include <windows.h>

#include <winreg.h>

#include <winsock2.h>

#include <ws2tcpip.h>

#include <string>



// MAC adresini alma fonksiyonu

std::string GetMacAddress() {

    std::string macAddress;

    IP_ADAPTER_INFO adapterInfo[16];

    DWORD bufferSize = sizeof(adapterInfo);



    DWORD result = GetAdaptersInfo(adapterInfo, &bufferSize);

    if (result == ERROR_SUCCESS) {

        PIP_ADAPTER_INFO adapter = adapterInfo;

        macAddress = adapter->Address[0];

        for (int i = 1; i < adapter->AddressLength; ++i) {

            char hex[3];

            sprintf_s(hex, "%.2X", adapter->Address[i]);

            macAddress += ":" + std::string(hex);

        }

    }



    return macAddress;

}



// Diğer bileşenlerin HWID'ye eklenmesi ve API'ye gönderilmesi

int main() {

    // MAC adresini al

    std::string macAddress = GetMacAddress();



    // Diğer bileşenlerin değerlerini al

    std::string hardwareID = "1234567890"; // Örnek bir hardware ID

    std::string windowsKey = "ABCDE-12345-FGHIJ-67890"; // Örnek bir Windows key

    std::string biosID = "ABC123"; // Örnek bir BIOS ID

    std::string ssdID = "SSD-1234567890"; // Örnek bir SSD ID



    // HWID'yi oluştur

    std::string hwid = macAddress + hardwareID + windowsKey + biosID + ssdID;



    // API endpoint adresini ve parametreleri belirle

    std::string apiEndpoint = "https://your-domain.com/your-api-endpoint.php";

    std::string apiParams = "?hwid=" + hwid;



    // API'ye GET isteği yap

    WSADATA wsaData;

    if (WSAStartup(MAKEWORD(2, 2), &wsaData) != 0) {

        std::cerr << "WSAStartup failed." << std::endl;

        return 1;

    }



    struct addrinfo* result = NULL, * ptr = NULL, hints;

    ZeroMemory(&hints, sizeof(hints));

    hints.ai_family = AF_UNSPEC;

    hints.ai_socktype = SOCK_STREAM;

    hints.ai_protocol = IPPROTO_TCP;



    if (getaddrinfo(apiEndpoint.c_str(), "https", &hints, &result) != 0) {

        std::cerr << "getaddrinfo failed." << std::endl;

        WSACleanup();

        return 1;

    }



    SOCKET connectSocket = INVALID_SOCKET;

    for (ptr = result; ptr != NULL; ptr = ptr->ai_next) {

        connectSocket = socket(ptr

C++ kodlarının çalışma mantığını açıklayayım:


İlk olarak, GetMacAddress() fonksiyonunu kullanarak MAC adresini alıyoruz. Bunun için Windows API'lerini (GetAdaptersInfo) kullanıyoruz.

Ardından, diğer bileşenlerin değerlerini örnek olarak belirliyoruz. Bu değerleri gerçek sistemde ilgili bileşenlerden almanız gerekecektir.

Sonra, diğer bileşenlerin değerlerini kullanarak HWID'yi oluşturuyoruz. Bu, MAC adresi, hardware ID, Windows key, BIOS ID ve SSD ID'nin birleşimidir.

API endpoint adresini ve parametreleri belirliyoruz. apiEndpoint değişkenine API endpoint URL'sini, apiParams değişkenine ise HWID'yi içeren GET parametrelerini ekliyoruz.

WSAStartup işlevini kullanarak Winsock'u başlatıyoruz.

getaddrinfo işlevini kullanarak API endpoint'inin IP adresini alıyoruz.

Soket oluşturarak API'ye bağlanıyoruz.

API endpoint'i ve parametrelerini içeren GET isteğini API'ye gönderiyoruz.

Bu kod parçacığı, C++ dilinde MAC adresi almayı, diğer bileşenlerin değerlerini belirlemeyi, HWID oluşturmayı ve API'ye GET isteği göndermeyi sağlar. Gerçek sistemde, diğer bileşenlerin değerlerini almak için ilgili Windows API'lerini ve yöntemleri kullanmanız gerekecektir.


Bu kodları ihtiyaçlarınıza göre uyarlayarak, örneğin diğer bileşenlerin değerlerini doğru bir şekilde alarak ve güvenlik önlemleri ekleyerek kullanabilirsiniz.

Genişletmek için tıklayın ...