C++: Offline-Lizenzaktivierung für isolierte Rechner

1. Wählen Sie eine Offline-Richtlinie

Für C++-Software auf einem vom Netz getrennten Rechner exportieren Sie eine gerätegebundene Aktivierungsanfrage, genehmigen sie auf einem Rechner mit Internetzugang und importieren die signierte Antwort auf dem ursprünglichen Gerät. Dieser Dateiaustausch setzt eine gerätegebundene Lizenz voraus, deren Richtlinie die Offlineaktivierung erlaubt. Floating-Lizenzen benötigen weiterhin eine Onlinesitzung.

Das Gerätekontingent zählt aktuelle Aktivierungen und wird bei Freigabe wieder verfügbar. Normale Lizenzen zählen auch offline; bei Floating-Lizenzen gibt auch ein abgelaufener Lease das Kontingent frei.

1. Kopieren Sie die Produkt-ID unter Konsole > Produkte. Öffnen Sie die Signaturprüfschlüssel dieses Produkts und tragen Sie alle Schlüssel-ID/Public-Key-Paare im Initialisierungscode ein. Ersetzen Sie YOUR_PRODUCT_ID, YOUR_KEY_ID und YOUR_PUBLIC_KEY. Die Schnellintegration kann den Code erzeugen. Eine Produktkonfigurationsdatei ist nicht erforderlich; das SDK verwendet standardmäßig https://www.licentivo.com.

SDK-Dokumentation

2. Installieren Sie die native Version SDK

Installieren Sie CMake 3.18 oder neuer. Verwenden Sie unter Windows x64 die Visual Studio 2022 C++ Build Tools und das passende MSVC-SDK-Paket mit -G "Visual Studio 17 2022" -A x64. Unter Linux x64 benötigen Sie C11-/C++17-Compiler. Ersetzen Sie SDK_PREFIX durch den vom Installationsprogramm ausgegebenen CMake-Präfix. Speichern Sie das Beispiel als offline.cpp und die folgende CMakeLists.txt im selben Verzeichnis. Installieren und kompilieren Sie auf einem Rechner mit Internetzugang und kopieren Sie danach die ausführbare Datei samt Laufzeitabhängigkeiten auf den Offline-Rechner.

Installieren Sie ein Entwicklungspaket für die gemeinsam genutzte libcurl-Bibliothek passend zu Compiler und Architektur. Ersetzen Sie unter Windows mit MSVC x64 CURL_DIR durch das Verzeichnis mit CURLConfig.cmake, nehmen Sie das bin-Verzeichnis von curl für lokale Tests in PATH auf und liefern Sie benötigte DLLs mit; installieren Sie unter Linux das entsprechende libcurl-Entwicklungspaket Ihrer Distribution.

& ([scriptblock]::Create((Invoke-WebRequest 'https://www.licentivo.com/assets/sdk/releases/v0.11.6/install.ps1').Content)) -Language cpp -Toolchain msvc

curl --fail --silent --show-error --location --proto '=https' --proto-redir '=https' 'https://www.licentivo.com/assets/sdk/releases/v0.11.6/install.sh' | bash -s -- cpp

cmake_minimum_required(VERSION 3.18)
project(offline_activation LANGUAGES C CXX)
find_package(Licentivo 0.11.6 REQUIRED)
add_executable(offline offline.cpp)
target_link_libraries(offline PRIVATE Licentivo::CPP)
set_target_properties(offline PROPERTIES CXX_STANDARD 17 CXX_STANDARD_REQUIRED ON)

cmake -S . -B build -G "Visual Studio 17 2022" -A x64 -DCMAKE_PREFIX_PATH="SDK_PREFIX" -DCURL_DIR="CURL_DIR"
if ($LASTEXITCODE -ne 0) { throw 'CMake configure failed. Check the SDK prefix and matching libcurl development package.' }
cmake --build build --config Release --target offline
if ($LASTEXITCODE -ne 0) { throw 'Build failed.' }

set -e
cmake -S . -B build -DCMAKE_BUILD_TYPE=Release -DCMAKE_PREFIX_PATH="SDK_PREFIX"
cmake --build build --target offline

SDK-Dokumentation

3. Export und Import mit SDK

Speichern Sie das Beispiel als offline.cpp und fügen Sie es Ihrem SDK-aktivierten CMake-Projekt hinzu. Führen Sie die Offline-Anfrage YOUR_LICENSE_KEY auf dem Offline-Computer aus. Es erzeugt die Aktivierung.request.json, ohne einen Online-Client zu öffnen.

Verschieben Sie diese Anfrage auf einen angeschlossenen Computer. Laden Sie in der Anbieterkonsole oder im zugehörigen Kundenportal die Anfrage hoch und laden Sie die genehmigte Antwort herunter. Speichern Sie es als Aktivierung.response.json, geben Sie dann beide Dateien auf den ursprünglichen Computer zurück und führen Sie den Offline-Import YOUR_LICENSE_KEY aus.

#include "licentivo.hpp"
#include <fstream>
#include <iostream>
#include <iterator>
#include <stdexcept>
#include <string>

// BEGIN LICENTIVO PRODUCT
// Copy Product ID and all key ID/public key pairs from Console > Products > Signing public keys.
static const std::string PRODUCT_ID = "YOUR_PRODUCT_ID";
static const std::string TRUSTED_KEYS_JSON = R"({"YOUR_KEY_ID":"YOUR_PUBLIC_KEY"})";
// END LICENTIVO PRODUCT

std::string readText(const char* path) {
    std::ifstream file(path);
    if (!file) throw std::runtime_error("Cannot read file");
    return {std::istreambuf_iterator<char>(file), {}};
}

int main(int argc, char** argv) {
    try {
        // Product settings are in code; the key is entered by the customer.
        if (argc < 3) throw std::runtime_error("Usage: offline request|import LICENSE_KEY");
        auto client = licentivo::Client::ForProduct(PRODUCT_ID, TRUSTED_KEYS_JSON, argv[2]);
        if (std::string(argv[1]) == "request") {
            std::ofstream file("activation.request.json");
            file << client.OfflineRequest();
            if (!file) throw std::runtime_error("Cannot save request");
            std::cout << "Created activation.request.json\n";
        } else if (std::string(argv[1]) == "import") {
            client.ImportOffline(readText("activation.request.json"),
                                 readText("activation.response.json"));
            client.RunFeature("export", [] {
                std::ofstream file("licensed-report.txt");
                file << "Licensed offline export\n";
                if (!file) throw std::runtime_error("Cannot save report");
            });
            std::cout << "Created licensed-report.txt\n";
        } else {
            throw std::runtime_error("Unknown operation");
        }
    } catch (const std::exception& error) {
        std::cerr << error.what() << '\n';
        return 1;
    }
}

./build/Release/offline.exe request YOUR_LICENSE_KEY

./build/Release/offline.exe import YOUR_LICENSE_KEY

./build/offline request YOUR_LICENSE_KEY

./build/offline import YOUR_LICENSE_KEY

Offline-Dateiaktivierung

4. Überprüfen Sie das Ergebnis

1. Bestätigen Sie, dass der Import erfolgreich ist und licensed-report.txt erstellt wird.
2. Starten Sie mit den gespeicherten Geräteanmeldeinformationen und demselben Cache-Speicherort neu. Ein noch gültiger Offline-Lease sollte die berechtigte Funktion ermöglichen.
3. Versuchen Sie den Import auf einem anderen normalen Computer: Die Gerätevalidierung sollte diese Antwort ablehnen.
4. Überprüfen Sie den Ablauf der Autorisierung und die Offline-Dauer. Durch den Dateiimport wird die ursprüngliche Lizenz nicht erweitert oder die Nutzung über die unterzeichneten Grenzen hinaus gestattet.

Eine Softwarelizenz auf einen neuen Computer übertragen

Verwendung der C-Schnittstelle

Erzeugen Sie in C mit ln_init_product einen noch nicht gestarteten Client und übergeben Sie Produkt-ID, vertrauenswürdige öffentliche Schlüssel und Kundenlizenzschlüssel. Erstellen Sie die Anfrage mit ln_offline_request; prüfen und importieren Sie Anfrage und Antwort mit ln_import_offline. Geben Sie zurückgegebene Zeichenfolgen mit ln_free_string und den Client mit ln_destroy frei.

Rufen Sie bei der ersten vollständig offline durchgeführten Aktivierung weder ln_start noch ln_open auf: Beide versuchen einen Onlinestart. Nutzen Sie den oben beschriebenen Anfrage- und Importablauf und überlassen Sie die Prüfung der signierten Antwort dem SDK; implementieren Sie keine eigene Signaturauswertung in der Anwendungslogik.

Softwarelizenzierung in C: SDK und CMake

Häufige Fehler und Betriebsgrenzen

Prüfen Sie Produkt-ID, alle Schlüssel-ID/Public-Key-Paare und den eingegebenen Lizenzschlüssel. Öffentliche Prüfschlüssel gehören zum Produkt; Kundenlizenzen und Geräteanmeldedaten sind getrennt. Verteilen Sie keine Testschlüssel oder Verwaltungs-API-Keys.

Eine ungültige Antwort kann bedeuten, dass die ursprüngliche Anfrage, das Produkt, das Gerät, der Signaturschlüssel oder die Anwendungsversion nicht übereinstimmt. Senden Sie die signierte Antwort zurück an den Computer, der die Anfrage generiert hat. Bearbeiten Sie nicht die Payloads JSON und deaktivieren Sie die Überprüfung nicht.

Für eine abgelaufene Anfrage ist eine neue Anfrage und Genehmigung erforderlich. Ein abgelaufener Lease muss gemäß der Richtlinie erneuert oder durch einen anderen genehmigten Dateiaustausch ersetzt werden. Online-gemessene Reserve-/Commit-Vorgänge sind nicht verfügbar, wenn sie vollständig offline sind.

Eine Fernfreigabe bzw. Sperrung wird erst bei der nächsten Online-Prüfung des Altgerätes bekannt. Ein dauerhaft offline befindliches Gerät kann eine serverseitige Änderung nicht sofort erlernen. Wählen Sie die Offline-Dauer unter Berücksichtigung dieser Einschränkung.