Ativação offline de licenças em C++

1. Escolha uma política offline

Para um software C++ em um computador isolado da rede, exporte uma solicitação de ativação vinculada ao dispositivo, aprove-a em um computador conectado à Internet e importe a resposta assinada no computador original. Essa troca de arquivos exige uma licença vinculada ao dispositivo cuja política permita ativação offline. Licenças flutuantes continuam exigindo uma sessão online.

A cota conta as ativações atuais e retorna ao liberá-las. Licenças comuns continuam contando offline; licenças flutuantes também devolvem a cota quando a concessão expira.

1. Copie o ID do produto em Console > Produtos. Abra as chaves públicas de assinatura do mesmo produto e insira todos os pares ID da chave/chave pública no código de inicialização, substituindo YOUR_PRODUCT_ID, YOUR_KEY_ID e YOUR_PUBLIC_KEY. A integração rápida pode gerar esse código. Não é necessário um arquivo de configuração; o SDK usa https://www.licentivo.com por padrão.

SDK documentação

2. Instale o nativo SDK

Instale o CMake 3.18 ou posterior. No Windows x64, use Visual Studio 2022 C++ Build Tools e o pacote SDK MSVC correspondente, com -G "Visual Studio 17 2022" -A x64. No Linux x64, use compiladores C11/C++17. Substitua SDK_PREFIX pelo prefixo do CMake exibido pelo instalador. Salve o exemplo como offline.cpp e o CMakeLists.txt abaixo no mesmo diretório. Faça a instalação e a compilação em um computador conectado e depois copie o executável e suas dependências de execução para o computador offline.

Instale um pacote de desenvolvimento de libcurl compartilhada compatível com o compilador e a arquitetura. No Windows MSVC x64, substitua CURL_DIR pelo diretório que contém CURLConfig.cmake, adicione o diretório bin do curl ao PATH para os testes locais e distribua as DLLs necessárias com o aplicativo; no Linux, instale o pacote de desenvolvimento de libcurl compartilhada da sua distribuição.

& ([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 documentação

3. Exportar e importar usando o SDK

Salve o exemplo como offline.cpp e adicione-o ao seu projeto CMake habilitado para SDK. Execute a solicitação offline YOUR_LICENSE_KEY no computador offline. Produz ativação.request.json sem abrir um cliente online.

Mova essa solicitação para um computador conectado. No console do fornecedor ou no portal do cliente associado, carregue a solicitação e baixe sua resposta aprovada. Salve-o como ativação.response.json, retorne os dois arquivos ao computador original e execute a importação 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_KEY

Ativação de arquivo offline

4. Confira o resultado

1. Confirme se a importação foi bem-sucedida e licensed-report.txt foi criado.
2. Reinicie usando a credencial do dispositivo armazenada e o mesmo local de cache. Uma concessão off-line ainda válida deve permitir o recurso autorizado.
3. Tente importar em outro computador comum: a validação do dispositivo deverá rejeitar essa resposta.
4. Verifique o vencimento da autorização e a duração off-line. A importação de arquivos não estende a licença original nem permite o uso além dos limites assinados.

Como transferir uma licença de software para outro computador

Usando a interface C

Em C, crie um cliente ainda não iniciado com ln_init_product, passando o ID do produto, as chaves públicas confiáveis e a chave de licença do cliente. Gere a solicitação com ln_offline_request e verifique e importe a solicitação e a resposta com ln_import_offline. Libere as strings retornadas com ln_free_string e o cliente com ln_destroy.

Na primeira ativação totalmente offline, não chame ln_start nem ln_open: essas funções tentam iniciar online. Use o fluxo de solicitação e importação acima e deixe o SDK verificar a resposta assinada; não implemente a interpretação de assinaturas na lógica do aplicativo.

SDK de licenciamento em C: tutorial CMake

Falhas comuns e limites operacionais

Confira o ID do produto, todos os pares ID da chave/chave pública e a licença do cliente. As chaves públicas pertencem ao produto; licenças e credenciais de dispositivos são separadas. Não distribua chaves de teste ou API Keys de gerenciamento.

Uma resposta inválida pode significar que a solicitação original, o produto, o dispositivo, a chave de assinatura ou a versão do aplicativo não correspondem. Traga a resposta assinada de volta ao computador que gerou sua solicitação. Não edite as cargas JSON nem desative a verificação.

Uma solicitação expirada precisa de uma nova solicitação e aprovação. Um arrendamento expirado precisa de renovação ou outra troca de arquivos aprovada de acordo com a política. As operações de reserva/confirmação medidas on-line ficam indisponíveis enquanto estão totalmente off-line.

Uma desvinculação ou revogação remota torna-se conhecida na próxima verificação online do dispositivo antigo. Um dispositivo permanentemente off-line não pode aprender imediatamente uma alteração no servidor. Escolha a duração offline tendo essa limitação em mente.