1. Elija una política fuera de línea
Para software C++ en un equipo aislado de la red, exporta una solicitud de activación vinculada al dispositivo, apruébala desde un equipo con Internet e importa la respuesta firmada en el equipo original. Este intercambio de archivos requiere una licencia vinculada al dispositivo cuya política permita la activación sin conexión. Las licencias flotantes siguen necesitando una sesión en línea.
La cuota cuenta las activaciones actuales y se recupera al liberarlas. Las licencias normales cuentan sin conexión; las flotantes también liberan cuota al vencer su arrendamiento.
- Copia el ID del producto en Consola > Productos. Abre las claves públicas de firma del mismo producto y pega todos los pares ID de clave/clave pública en el código de inicialización, sustituyendo YOUR_PRODUCT_ID, YOUR_KEY_ID y YOUR_PUBLIC_KEY. La integración rápida puede generar este código. No hace falta un archivo de configuración; el SDK usa https://www.licentivo.com de forma predeterminada.
2. Instale el SDK nativo
Instala CMake 3.18 o posterior. En Windows x64, usa Visual Studio 2022 C++ Build Tools y el paquete SDK MSVC correspondiente, con -G "Visual Studio 17 2022" -A x64. En Linux x64, utiliza compiladores C11/C++17. Sustituye SDK_PREFIX por el prefijo de CMake que muestre el instalador. Guarda el ejemplo como offline.cpp y el CMakeLists.txt siguiente en el mismo directorio. Completa la instalación y la compilación en un equipo conectado y después copia el ejecutable y sus dependencias de ejecución al equipo sin conexión.
Instala un paquete de desarrollo de libcurl compartida compatible con el compilador y la arquitectura. En Windows MSVC x64, sustituye CURL_DIR por el directorio que contiene CURLConfig.cmake, añade el directorio bin de curl a PATH para las pruebas locales y distribuye las DLL necesarias con la aplicación; en Linux, instala el paquete de desarrollo de libcurl compartida de tu distribución.
& ([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. Exportar e importar utilizando el SDK
Guarde el ejemplo como offline.cpp y agréguelo a su proyecto CMake habilitado para SDK. Ejecute la solicitud sin conexión YOUR_LICENSE_KEY en la computadora sin conexión. Produce activación.request.json sin abrir un cliente en línea.
Mueva esa solicitud a una computadora conectada. En la consola del proveedor o en el portal del cliente asociado, cargue la solicitud y descargue su respuesta aprobada. Guárdelo como activación.response.json, luego devuelva ambos archivos a la computadora original y ejecute la importación sin conexión 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. Comprueba el resultado
- Confirme que la importación se realizó correctamente y se crea licensed-report.txt.
- Reinicie utilizando la credencial del dispositivo almacenada y la misma ubicación de caché. Un contrato de arrendamiento fuera de línea aún válido debería permitir la función autorizada.
- Intente importar en otra computadora común: la validación del dispositivo debería rechazar esa respuesta.
- Verifique el vencimiento de la autorización y la duración sin conexión. La importación de archivos no extiende la licencia original ni permite el uso más allá de los límites firmados.
Usando la interfaz C
En C, crea un cliente sin iniciar con ln_init_product, pasando el ID del producto, las claves públicas de confianza y la clave de licencia del cliente. Genera la solicitud con ln_offline_request y verifica e importa la solicitud y la respuesta con ln_import_offline. Libera las cadenas devueltas con ln_free_string y el cliente con ln_destroy.
En la primera activación completamente sin conexión, no llames a ln_start ni a ln_open: intentan iniciar en línea. Usa el flujo de solicitud e importación anterior y deja que el SDK verifique la respuesta firmada; no implementes el análisis de firmas en la lógica de la aplicación.
Fallos comunes y límites operativos
Comprueba el ID del producto, todos los pares ID de clave/clave pública y la licencia del cliente. Las claves públicas pertenecen al producto; las licencias y credenciales de dispositivo son independientes. No distribuyas claves de prueba ni API Keys de gestión.
Una respuesta no válida puede significar que la solicitud, el producto, el dispositivo, la clave de firma o la versión de la aplicación originales no coinciden. Devuelva la respuesta firmada a la computadora que generó su solicitud. No edite las cargas útiles JSON ni desactive la verificación.
Una solicitud caducada necesita una nueva solicitud y aprobación. Un contrato de arrendamiento vencido necesita renovación u otro intercambio de archivos aprobado según la política. Las operaciones de reserva/compromiso medidas en línea no están disponibles mientras esté completamente fuera de línea.
Una desvinculación o revocación remota se conoce en la siguiente verificación en línea del dispositivo antiguo. Un dispositivo permanentemente fuera de línea no puede aprender inmediatamente un cambio del lado del servidor. Elija la duración sin conexión teniendo en cuenta esa limitación.