license.hpp

Go to the documentation of this file.

#pragma once
 
// License key validation — plugin licensing.
//
// Format versions:
//   v1 — legacy: base64(json).base64(RSA_SHA256(json)). Asymmetric;
//        server holds an RSA private key, plugin embeds the public PEM.
//        Continues to validate for one release window for backward compat.
//   v2 — current: "v2." + base64url(IV || AES-256-GCM(json) || tag).
//        Symmetric; server + plugin share a 32-byte secret. Smaller keys,
//        no PEM parsing, and the GCM tag covers integrity (eliminates the
//        separate signature). HMAC-SHA256 is still available as a standalone
//        primitive for use cases (e.g. activation tokens) that need MAC
//        without payload encryption.
 
#include <pulp/runtime/crypto.hpp>
#include <string>
#include <string_view>
#include <optional>
#include <vector>
#include <cstdint>
 
namespace pulp::runtime {

enum class LicenseFormatVersion {
    V1 = 1,  
    V2 = 2,  
};

inline constexpr LicenseFormatVersion kCurrentLicenseFormat =
    LicenseFormatVersion::V2;

enum class LicenseStatus {
    Valid,
    Expired,
    InvalidSignature,
    InvalidFormat,
    MachineIdMismatch,
    NotFound
};

struct LicenseInfo {
    std::string product_id;
    std::string user_email;
    std::string machine_id;    // Empty = any machine
    int64_t issued_timestamp = 0;
    int64_t expiry_timestamp = 0;  // 0 = perpetual
    std::string edition;       // "standard", "pro", etc.
};

class LicenseValidator {
public:
    LicenseValidator() = default;

    void set_public_key(std::string_view pem);

    void set_shared_secret(const uint8_t* secret_32, size_t secret_size);

    LicenseStatus validate(std::string_view license_key) const;

    std::optional<LicenseInfo> validate_and_parse(std::string_view license_key) const;

    LicenseStatus validate_file(std::string_view path) const;

    bool is_valid_for_machine(const LicenseInfo& info) const;
 
private:
    std::string public_key_pem_;
    std::vector<uint8_t> shared_secret_;
 
    std::optional<LicenseInfo> parse_payload(std::string_view json) const;
    bool verify_signature(std::string_view payload, std::string_view signature_b64) const;
 
    LicenseStatus validate_v1(std::string_view license_key) const;
    LicenseStatus validate_v2(std::string_view license_key) const;
};

class LicenseGenerator {
public:
    LicenseGenerator() = default;

    void set_private_key(std::string_view pem);

    void set_shared_secret(const uint8_t* secret_32, size_t secret_size);

    std::optional<std::string> generate(const LicenseInfo& info) const;

    std::optional<std::string> generate_v1(const LicenseInfo& info) const;

    std::optional<std::string> generate_v2(const LicenseInfo& info) const;
 
private:
    std::string private_key_pem_;
    std::vector<uint8_t> shared_secret_;
};
 
// ── Format helpers and migration ────────────────────────────────────────

std::optional<LicenseFormatVersion> detect_license_format(
    std::string_view license_key);

std::optional<std::string> migrate_v1_to_v2(
    std::string_view v1_license_key,
    std::string_view v1_public_key_pem,
    const uint8_t* v2_secret_32,
    size_t v2_secret_size);

struct OnlineActivationOptions {
    bool allow_insecure_http = false;
    int timeout_seconds = 30;
};

struct OnlineActivation {
    static std::optional<std::string> activate(std::string_view server_url,
                                               std::string_view serial_number,
                                               std::string_view product_id,
                                               const OnlineActivationOptions& options = {});

    static bool deactivate(std::string_view server_url, std::string_view license_key,
                           const OnlineActivationOptions& options = {});

    static LicenseStatus check_status(std::string_view server_url, std::string_view license_key,
                                      const OnlineActivationOptions& options = {});

    static bool server_url_allowed(std::string_view server_url,
                                   const OnlineActivationOptions& options = {});

    static LicenseStatus parse_status_response(std::string_view body);
};
 
}  // namespace pulp::runtime