1. Scegli una policy offline
Per un software C++ su un computer isolato dalla rete, esporta una richiesta di attivazione legata al dispositivo, approvala da un computer connesso a Internet e importa la risposta firmata sul computer originale. Questo scambio di file richiede una licenza legata al dispositivo con una policy che consenta l'attivazione offline. Le licenze floating richiedono comunque una sessione online.
La quota conta le attivazioni correnti e viene restituita al rilascio. Le licenze ordinarie contano anche offline; quelle flottanti restituiscono la quota anche alla scadenza del lease.
- Copia l’ID prodotto da Console > Prodotti. Apri le chiavi pubbliche di firma dello stesso prodotto e inserisci tutte le coppie ID chiave/chiave pubblica nel codice di inizializzazione, sostituendo YOUR_PRODUCT_ID, YOUR_KEY_ID e YOUR_PUBLIC_KEY. L’integrazione rapida può generare il codice. Non serve un file di configurazione; l’SDK usa https://www.licentivo.com per impostazione predefinita.
2. Installa il nativo SDK
Installa CMake 3.18 o successivo. Su Windows x64 usa Visual Studio 2022 C++ Build Tools e il pacchetto SDK MSVC corrispondente, con -G "Visual Studio 17 2022" -A x64. Su Linux x64 servono compilatori C11/C++17. Sostituisci SDK_PREFIX con il prefisso CMake mostrato dall'installer. Salva l'esempio come offline.cpp e il CMakeLists.txt seguente nella stessa cartella. Completa installazione e compilazione su un computer connesso, quindi copia l'eseguibile e le sue dipendenze di runtime sul computer offline.
Installare un pacchetto di sviluppo libcurl condiviso compatibile con compilatore e architettura. Su Windows MSVC x64, sostituire CURL_DIR con la directory contenente CURLConfig.cmake, aggiungere la directory bin di curl a PATH per le prove locali e distribuire le DLL necessarie con l'applicazione; su Linux, installare il pacchetto di sviluppo libcurl condiviso della distribuzione.
& ([scriptblock]::Create((Invoke-WebRequest 'https://www.licentivo.com/assets/sdk/releases/v0.11.6/install.ps1').Content)) -Language cpp -Toolchain msvccurl --fail --silent --show-error --location --proto '=https' --proto-redir '=https' 'https://www.licentivo.com/assets/sdk/releases/v0.11.6/install.sh' | bash -s -- cppcmake_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 offline3. Esporta e importa utilizzando SDK
Salva l'esempio come offline.cpp e aggiungilo al tuo progetto CMake abilitato per SDK. Esegui la richiesta offline YOUR_LICENSE_KEY sul computer offline. Produce l'attivazione.request.json senza aprire un client online.
Sposta la richiesta su un computer connesso. Nella console del fornitore o nel portale del cliente associato, carica la richiesta e scarica la risposta approvata. Salvalo come attivazione.response.json, quindi ripristina entrambi i file sul computer originale ed esegui l'importazione offline YOUR_LICENSE_KEY.
#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_KEY4. Controlla il risultato
- Confermare che l'importazione ha esito positivo e che viene creato licensed-report.txt.
- Riavviare utilizzando le credenziali del dispositivo archiviate e la stessa posizione della cache. Un lease offline ancora valido dovrebbe consentire la funzionalità autorizzata.
- Prova a importare su un altro computer normale: la convalida del dispositivo dovrebbe rifiutare quella risposta.
- Controlla la scadenza dell'autorizzazione e la durata offline. L'importazione di file non estende la licenza originale né consente l'utilizzo oltre i limiti firmati.
Utilizzando l'interfaccia C
In C, crea un client non ancora avviato con ln_init_product, passando ID prodotto, chiavi pubbliche attendibili e chiave di licenza del cliente. Genera la richiesta con ln_offline_request, poi verifica e importa richiesta e risposta con ln_import_offline. Libera le stringhe restituite con ln_free_string e il client con ln_destroy.
Per la prima attivazione completamente offline, non chiamare ln_start o ln_open: tentano un avvio online. Usa il flusso di richiesta e importazione descritto sopra e lascia che l'SDK verifichi la risposta firmata; non implementare la lettura delle firme nella logica applicativa.
Guasti comuni e limiti operativi
Controlla ID prodotto, tutte le coppie ID chiave/chiave pubblica e la licenza del cliente. Le chiavi pubbliche appartengono al prodotto; licenze e credenziali dei dispositivi sono separate. Non distribuire chiavi di test o API Key di gestione.
Una risposta non valida può significare che la richiesta originale, il prodotto, il dispositivo, la chiave di firma o la versione dell'applicazione non corrispondono. Riporta la risposta firmata al computer che ha generato la richiesta. Non modificare i payload JSON né disabilitare la verifica.
Una richiesta scaduta necessita di una nuova richiesta e approvazione. Un lease scaduto necessita di rinnovo o di un altro scambio di file approvato in base alla politica. Le operazioni di riserva/impegno misurate online non sono disponibili mentre sei completamente offline.
Uno scioglimento o una revoca remota verranno resi noti al successivo controllo online del vecchio dispositivo. Un dispositivo permanentemente offline non può apprendere immediatamente una modifica sul lato server. Scegli la durata offline tenendo presente tale limitazione.