licensechain_ruby_sdk 1.0.1

data/lib/licensechain/api_client.rb

@@ -0,0 +1,139 @@
+require 'net/http'
+require 'uri'
+require 'json'
+require 'timeout'
+
+module LicenseChain
+  class ApiClient
+    include Utils
+
+    def initialize(config = nil)
+      @config = config || LicenseChain.configuration
+      raise ConfigurationError, "API key is required" unless @config.valid?
+    end
+
+    def get(endpoint, params = {})
+      make_request(:get, endpoint, nil, params)
+    end
+
+    def post(endpoint, data = nil)
+      make_request(:post, endpoint, data)
+    end
+
+    def put(endpoint, data = nil)
+      make_request(:put, endpoint, data)
+    end
+
+    def patch(endpoint, data = nil)
+      make_request(:patch, endpoint, data)
+    end
+
+    def delete(endpoint, data = nil)
+      make_request(:delete, endpoint, data)
+    end
+
+    private
+
+    def make_request(method, endpoint, data = nil, params = {})
+      uri = build_uri(endpoint, params)
+      request = build_request(method, uri, data)
+      
+      retry_with_backoff(@config.retries) do
+        response = send_request(uri, request)
+        handle_response(response)
+      end
+    rescue Timeout::Error
+      raise TimeoutError, "Request timed out"
+    rescue => e
+      raise NetworkError, "Network error: #{e.message}"
+    end
+
+    def build_uri(endpoint, params = {})
+      base_url = @config.base_url.sub(%r{/\z}, '')
+      base_has_v1 = base_url.end_with?('/v1')
+      normalized_endpoint = if endpoint.start_with?('/v1/')
+        base_has_v1 ? endpoint.sub(%r{\A/v1}, '') : endpoint
+      elsif endpoint.start_with?('/')
+        base_has_v1 ? endpoint : "/v1#{endpoint}"
+      else
+        base_has_v1 ? "/#{endpoint}" : "/v1/#{endpoint}"
+      end
+
+      uri = URI.parse("#{base_url}#{normalized_endpoint}")
+      uri.query = URI.encode_www_form(params) unless params.empty?
+      uri
+    end
+
+    def build_request(method, uri, data = nil)
+      case method
+      when :get
+        Net::HTTP::Get.new(uri)
+      when :post
+        request = Net::HTTP::Post.new(uri)
+        request.body = data.to_json if data
+        request
+      when :put
+        request = Net::HTTP::Put.new(uri)
+        request.body = data.to_json if data
+        request
+      when :patch
+        request = Net::HTTP::Patch.new(uri)
+        request.body = data.to_json if data
+        request
+      when :delete
+        request = Net::HTTP::Delete.new(uri)
+        request.body = data.to_json if data
+        request
+      else
+        raise ArgumentError, "Unsupported HTTP method: #{method}"
+      end.tap do |request|
+        add_headers(request)
+      end
+    end
+
+    def add_headers(request)
+      request['Authorization'] = "Bearer #{@config.api_key}"
+      request['Content-Type'] = 'application/json'
+      request['X-API-Version'] = '1.0'
+      request['X-Platform'] = 'ruby-sdk'
+      request['User-Agent'] = "LicenseChain-Ruby-SDK/1.0.0"
+    end
+
+    def send_request(uri, request)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http.read_timeout = @config.timeout
+        http.open_timeout = @config.timeout
+        http.request(request)
+      end
+    end
+
+    def handle_response(response)
+      case response.code.to_i
+      when 200..299
+        parse_response(response)
+      when 400
+        raise ValidationError, "Bad Request: #{response.body}"
+      when 401
+        raise AuthenticationError, "Unauthorized: #{response.body}"
+      when 403
+        raise AuthenticationError, "Forbidden: #{response.body}"
+      when 404
+        raise NotFoundError, "Not Found: #{response.body}"
+      when 429
+        raise RateLimitError, "Rate Limited: #{response.body}"
+      when 500..599
+        raise ApiError, "Server Error: #{response.body}"
+      else
+        raise UnknownError, "Unexpected response: #{response.code} #{response.body}"
+      end
+    end
+
+    def parse_response(response)
+      return {} if response.body.nil? || response.body.empty?
+      
+      JSON.parse(response.body, symbolize_names: true)
+    rescue JSON::ParserError => e
+      raise DeserializationError, "Failed to parse JSON response: #{e.message}"
+    end
+  end
+end

data/lib/licensechain/client.rb

@@ -0,0 +1,37 @@
+require_relative 'configuration'
+require_relative 'api_client'
+require_relative 'services/license_service'
+require_relative 'services/user_service'
+require_relative 'services/product_service'
+require_relative 'services/webhook_service'
+require_relative 'models'
+require_relative 'errors'
+require_relative 'utils'
+
+module LicenseChain
+  class Client
+    attr_reader :licenses, :users, :products, :webhooks
+
+    def initialize(config = nil)
+      @config = config || LicenseChain.configuration
+      @api_client = ApiClient.new(@config)
+      
+      @licenses = Services::LicenseService.new(@api_client)
+      @users = Services::UserService.new(@api_client)
+      @products = Services::ProductService.new(@api_client)
+      @webhooks = Services::WebhookService.new(@api_client)
+    end
+
+    def configuration
+      @config
+    end
+
+    def ping
+      @api_client.get('/health')
+    end
+
+    def health
+      @api_client.get('/health')
+    end
+  end
+end

data/lib/licensechain/configuration.rb

@@ -0,0 +1,41 @@
+module LicenseChain
+  class Configuration
+    attr_accessor :api_key, :base_url, :timeout, :retries, :logger
+
+    def initialize
+      @api_key = ENV['LICENSECHAIN_API_KEY']
+      @base_url = ENV['LICENSECHAIN_BASE_URL'] || 'https://api.licensechain.app/v1'
+      @timeout = 30
+      @retries = 3
+      @logger = Logger.new(STDOUT)
+    end
+
+    def valid?
+      !@api_key.nil? && !@api_key.empty?
+    end
+
+    def reset!
+      @api_key = nil
+      @base_url = 'https://api.licensechain.app/v1'
+      @timeout = 30
+      @retries = 3
+      @logger = Logger.new(STDOUT)
+    end
+  end
+
+  class << self
+    attr_writer :configuration
+
+    def configuration
+      @configuration ||= Configuration.new
+    end
+
+    def configure
+      yield(configuration)
+    end
+
+    def reset!
+      @configuration = Configuration.new
+    end
+  end
+end

data/lib/licensechain/enhanced_client.rb

@@ -0,0 +1,320 @@
+# frozen_string_literal: true
+
+require 'net/http'
+require 'json'
+require 'uri'
+require 'openssl'
+require 'base64'
+require 'time'
+require 'securerandom'
+
+module LicenseChain
+  # Enhanced client with reverse-engineered advanced patterns
+  class EnhancedClient < Client
+    attr_reader :session_id, :user_data, :initialized
+
+    def initialize(app_name:, owner_id:, app_secret:, base_url: 'https://api.licensechain.app/v1', timeout: 30, retries: 3)
+      super
+      @session_id = nil
+      @user_data = nil
+      @initialized = false
+    end
+
+    # Initialize the client and establish connection
+    def init
+      return true if @initialized
+
+      response = make_request('init', {
+        type: 'init',
+        ver: '1.0',
+        hash: generate_hash,
+        enckey: generate_encryption_key,
+        name: @app_name,
+        ownerid: @owner_id
+      })
+
+      if response['success']
+        @session_id = response['sessionid']
+        @initialized = true
+        true
+      else
+        false
+      end
+    end
+
+    # License-only login (advanced pattern)
+    def license_login(license:)
+      ensure_initialized
+      
+      response = make_request('license', {
+        type: 'license',
+        key: license,
+        hwid: get_hwid
+      })
+
+      if response['success']
+        @user_data = response['info']
+        response
+      else
+        raise LicenseChainError, response['message'] || 'License login failed'
+      end
+    end
+
+    # Check if user is logged in
+    def logged_in?
+      !@user_data.nil?
+    end
+
+    # Get current user data
+    def user_data
+      @user_data
+    end
+
+    # Get user's subscription information
+    def subscription
+      return nil unless logged_in?
+      @user_data['subscriptions']
+    end
+
+    # Set user variable
+    def setvar(var:, data:)
+      ensure_logged_in
+      
+      response = make_request('setvar', {
+        type: 'setvar',
+        var: var,
+        data: data,
+        sessionid: @session_id
+      })
+
+      response['success']
+    end
+
+    # Get user variable
+    def getvar(var:)
+      ensure_logged_in
+      
+      response = make_request('getvar', {
+        type: 'getvar',
+        var: var,
+        sessionid: @session_id
+      })
+
+      response['success'] ? response['data'] : nil
+    end
+
+    # Log message to LicenseChain
+    def log(message:)
+      ensure_logged_in
+      
+      response = make_request('log', {
+        type: 'log',
+        pcuser: get_pc_user,
+        message: message,
+        sessionid: @session_id
+      })
+
+      response['success']
+    end
+
+    # Download file from LicenseChain
+    def download(fileid:)
+      ensure_logged_in
+      
+      response = make_request('file', {
+        type: 'file',
+        fileid: fileid,
+        sessionid: @session_id
+      })
+
+      response['success'] ? response['contents'] : nil
+    end
+
+    # Get application statistics
+    def app_stats
+      ensure_initialized
+      
+      response = make_request('app', {
+        type: 'app',
+        sessionid: @session_id
+      })
+
+      response['success'] ? response : nil
+    end
+
+    # Get online users
+    def online_users
+      ensure_logged_in
+      
+      response = make_request('online', {
+        type: 'online',
+        sessionid: @session_id
+      })
+
+      response['success'] ? response['users'] : nil
+    end
+
+    # Chat functionality
+    def chat_get(channel:)
+      ensure_logged_in
+      
+      response = make_request('chatget', {
+        type: 'chatget',
+        channel: channel,
+        sessionid: @session_id
+      })
+
+      response['success'] ? response['messages'] : nil
+    end
+
+    def chat_send(message:, channel:)
+      ensure_logged_in
+      
+      response = make_request('chatsend', {
+        type: 'chatsend',
+        message: message,
+        channel: channel,
+        sessionid: @session_id
+      })
+
+      response['success']
+    end
+
+    # Admin functions
+    def ban_user(user:)
+      ensure_logged_in
+      
+      response = make_request('ban', {
+        type: 'ban',
+        user: user,
+        sessionid: @session_id
+      })
+
+      response['success']
+    end
+
+    def unban_user(user:)
+      ensure_logged_in
+      
+      response = make_request('unban', {
+        type: 'unban',
+        user: user,
+        sessionid: @session_id
+      })
+
+      response['success']
+    end
+
+    def all_users
+      ensure_logged_in
+      
+      response = make_request('allusers', {
+        type: 'allusers',
+        sessionid: @session_id
+      })
+
+      response['success'] ? response['users'] : nil
+    end
+
+    def get_user(username:)
+      ensure_logged_in
+      
+      response = make_request('getuser', {
+        type: 'getuser',
+        user: username,
+        sessionid: @session_id
+      })
+
+      response['success'] ? response['info'] : nil
+    end
+
+    def update_user(user:, data:)
+      ensure_logged_in
+      
+      response = make_request('edituser', {
+        type: 'edituser',
+        user: user,
+        data: data,
+        sessionid: @session_id
+      })
+
+      response['success']
+    end
+
+    def delete_user(user:)
+      ensure_logged_in
+      
+      response = make_request('deleteuser', {
+        type: 'deleteuser',
+        user: user,
+        sessionid: @session_id
+      })
+
+      response['success']
+    end
+
+    # Webhook functionality
+    def webhook
+      ensure_logged_in
+      
+      response = make_request('webhook', {
+        type: 'webhook',
+        sessionid: @session_id
+      })
+
+      response['success'] ? response : nil
+    end
+
+    def verify_webhook(payload:, signature:)
+      expected_signature = generate_webhook_signature(payload)
+      expected_signature == signature
+    end
+
+    def parse_webhook(payload:, signature:)
+      return nil unless verify_webhook(payload: payload, signature: signature)
+      
+      JSON.parse(payload)
+    rescue JSON::ParserError
+      nil
+    end
+
+    private
+
+    def ensure_initialized
+      raise LicenseChainError, 'Client not initialized. Call init() first.' unless @initialized
+    end
+
+    def ensure_logged_in
+      ensure_initialized
+      raise LicenseChainError, 'User not logged in' unless logged_in?
+    end
+
+    def generate_hash
+      data = "#{@app_name}#{@owner_id}#{@app_secret}"
+      Digest::SHA256.hexdigest(data)
+    end
+
+    def generate_encryption_key
+      SecureRandom.hex(16)
+    end
+
+    def get_hwid
+      require 'socket'
+      require 'sys/uname'
+      
+      hostname = Socket.gethostname
+      uname = Sys::Uname.uname
+      "#{hostname}-#{uname.machine}-#{uname.sysname}"
+    rescue
+      "unknown-hwid-#{SecureRandom.hex(8)}"
+    end
+
+    def get_pc_user
+      ENV['USER'] || ENV['USERNAME'] || 'unknown'
+    end
+
+    def generate_webhook_signature(payload)
+      "sha256=#{OpenSSL::HMAC.hexdigest('SHA256', @app_secret, payload)}"
+    end
+  end
+end

data/lib/licensechain/errors.rb

@@ -0,0 +1,15 @@
+module LicenseChain
+  class Error < StandardError; end
+  
+  class NetworkError < Error; end
+  class ApiError < Error; end
+  class ValidationError < Error; end
+  class AuthenticationError < Error; end
+  class NotFoundError < Error; end
+  class RateLimitError < Error; end
+  class TimeoutError < Error; end
+  class SerializationError < Error; end
+  class DeserializationError < Error; end
+  class ConfigurationError < Error; end
+  class UnknownError < Error; end
+end

data/lib/licensechain/license_assertion.rb

@@ -0,0 +1,67 @@
+# frozen_string_literal: true
+
+require 'jwt'
+require 'json'
+require 'uri'
+require 'net/http'
+
+module LicenseChain
+  # RS256 license_token verification via JWKS (parity with Node verifyLicenseAssertionJwt).
+  module LicenseAssertion
+    LICENSE_TOKEN_USE_CLAIM = 'licensechain_license_v1'
+
+    module_function
+
+    # @param expected_app_id [String, nil]
+    # @param issuer [String, nil]
+    # @return [Hash] decoded JWT payload
+    def verify_license_assertion_jwt(token, jwks_url, expected_app_id: nil, issuer: nil)
+      token = token.to_s.strip
+      raise ArgumentError, 'empty token' if token.empty?
+
+      jwks_url = jwks_url.to_s.strip
+      raise ArgumentError, 'empty jwks_url' if jwks_url.empty?
+
+      jwks = fetch_jwks(jwks_url)
+      decode_opts = {
+        algorithms: ['RS256'],
+        jwks: jwks,
+        verify_aud: false
+      }
+      if issuer && !issuer.to_s.strip.empty?
+        decode_opts[:verify_iss] = true
+        decode_opts[:iss] = issuer.to_s.strip
+      end
+
+      payload, = JWT.decode(token, nil, true, decode_opts)
+
+      tu = payload['token_use']
+      if tu != LICENSE_TOKEN_USE_CLAIM
+        raise JWT::DecodeError, %(Invalid license token: expected token_use "#{LICENSE_TOKEN_USE_CLAIM}")
+      end
+
+      if expected_app_id && !expected_app_id.to_s.strip.empty?
+        want = expected_app_id.to_s.strip
+        aud = payload['aud']
+        ok = aud == want || (aud.is_a?(Array) && aud.include?(want))
+        raise JWT::DecodeError, 'Invalid license token: aud does not match expected app id' unless ok
+      end
+
+      payload
+    end
+
+    def fetch_jwks(jwks_url)
+      uri = URI.parse(jwks_url)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.use_ssl = uri.scheme == 'https'
+      http.open_timeout = 20
+      http.read_timeout = 20
+      req = Net::HTTP::Get.new(uri.request_uri)
+      res = http.request(req)
+      raise JWT::DecodeError, "JWKS HTTP #{res.code}" unless res.is_a?(Net::HTTPSuccess)
+
+      JSON.parse(res.body)
+    end
+    private_class_method :fetch_jwks
+  end
+end