1. Choisissez une politique hors ligne
Pour un logiciel C++ sur un ordinateur isolé du réseau, exportez une demande d'activation liée à l'appareil, approuvez-la depuis un ordinateur connecté à Internet, puis importez la réponse signée sur l'ordinateur d'origine. Cet échange de fichiers nécessite une licence liée à l'appareil dont la politique autorise l'activation hors ligne. Les licences flottantes exigent toujours une session en ligne.
Le quota compte les activations actuelles et est rendu à leur libération. Les licences ordinaires restent comptées hors ligne ; les licences flottantes rendent aussi le quota à l’expiration du bail.
- Copiez l’ID du produit dans Console > Produits. Ouvrez les clés publiques de signature du même produit et collez toutes les paires ID de clé/clé publique dans le code d’initialisation, en remplaçant YOUR_PRODUCT_ID, YOUR_KEY_ID et YOUR_PUBLIC_KEY. L’intégration rapide peut générer ce code. Aucun fichier de configuration n’est nécessaire ; le SDK utilise https://www.licentivo.com par défaut.
2. Installez le SDK natif
Installez CMake 3.18 ou une version ultérieure. Sous Windows x64, utilisez Visual Studio 2022 C++ Build Tools et le paquet SDK MSVC correspondant, avec -G "Visual Studio 17 2022" -A x64. Sous Linux x64, utilisez des compilateurs C11/C++17. Remplacez SDK_PREFIX par le préfixe CMake affiché par l'installateur. Enregistrez l'exemple sous offline.cpp et le CMakeLists.txt ci-dessous dans le même répertoire. Effectuez l'installation et la compilation sur un ordinateur connecté, puis copiez l'exécutable et ses dépendances d'exécution sur l'ordinateur hors ligne.
Installez un paquet de développement libcurl partagé compatible avec le compilateur et l’architecture. Sous Windows MSVC x64, remplacez CURL_DIR par le dossier contenant CURLConfig.cmake, ajoutez le dossier bin de curl à PATH pour les essais locaux et distribuez les DLL nécessaires avec l’application ; sous Linux, installez le paquet de développement libcurl partagé de votre distribution.
& ([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. Exportez et importez en utilisant le SDK
Enregistrez l'exemple sous offline.cpp et ajoutez-le à votre projet CMake compatible SDK. Exécutez la demande hors ligne YOUR_LICENSE_KEY sur l'ordinateur hors ligne. Il produit l'activation.request.json sans ouvrir de client en ligne.
Déplacez cette demande vers un ordinateur connecté. Dans la console du fournisseur ou sur le portail du client associé, chargez la demande et téléchargez sa réponse approuvée. Enregistrez-le sous activation.response.json, puis renvoyez les deux fichiers sur l'ordinateur d'origine et exécutez l'importation hors ligne 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. Vérifiez le résultat
- Confirmez que l'importation réussit et que licensed-report.txt est créé.
- Redémarrez en utilisant les informations d'identification de l'appareil stockées et le même emplacement de cache. Un bail hors ligne toujours valide devrait permettre la fonctionnalité autorisée.
- Essayez d'importer sur un autre ordinateur ordinaire : la validation du périphérique devrait rejeter cette réponse.
- Vérifiez l'expiration de l'autorisation et la durée hors ligne. L'importation de fichiers n'étend pas la licence d'origine ni n'autorise l'utilisation au-delà de ses limites signées.
Utilisation de l'interface C
En C, créez un client non démarré avec ln_init_product, en passant l'ID du produit, les clés publiques de confiance et la clé de licence du client. Générez la demande avec ln_offline_request, puis vérifiez et importez la demande et la réponse avec ln_import_offline. Libérez les chaînes renvoyées avec ln_free_string et le client avec ln_destroy.
Lors de la première activation entièrement hors ligne, n'appelez ni ln_start ni ln_open : ces fonctions tentent un démarrage en ligne. Utilisez le flux de demande et d'importation ci-dessus et laissez le SDK vérifier la réponse signée ; n'implémentez pas l'analyse des signatures dans la logique métier.
Pannes courantes et limites opérationnelles
Vérifiez l’ID produit, toutes les paires ID de clé/clé publique et la licence du client. Les clés publiques appartiennent au produit ; licences et identifiants des appareils sont distincts. Ne distribuez pas de clés de test ou de clés API de gestion.
Une réponse non valide peut signifier que la demande, le produit, l'appareil, la clé de signature ou la version d'application d'origine ne correspondent pas. Ramenez la réponse signée à l'ordinateur qui a généré sa demande. Ne modifiez pas les charges utiles JSON et ne désactivez pas la vérification.
Une demande expirée nécessite une nouvelle demande et une approbation. Un bail expiré doit être renouvelé ou un autre échange de fichiers approuvé conformément à la politique. Les opérations de réserve/commit mesurées en ligne ne sont pas disponibles lorsqu'elles sont entièrement hors ligne.
Une dissociation ou une révocation à distance est connue lors de la prochaine vérification en ligne de l'ancien appareil. Un appareil définitivement hors ligne ne peut pas immédiatement apprendre une modification côté serveur. Choisissez la durée hors ligne en gardant cette limitation à l'esprit.