Welcome to OXYLicenser

// 1. Initialize Client with RSA Verification
$oxy = new OXYLicenseClient(
    'https://license-server.com', 
    $_POST['key'], 
    'PRD-XXXXXX', // Your Product ID
    '-----BEGIN PUBLIC KEY----- ... ----END PUBLIC KEY-----' // Product RSA Public Key
);

// 2. Send Activation request
$result = $oxy->activate_license();

if ($result['success']) {
    // ✅ Save License Key AND Public Key to your local config
    save_local_config($_POST['key'], '-----BEGIN PUBLIC KEY----- ...');
} else {
    // ❌ Show error: "Invalid Key" or "Expired"
    echo $result['message'];
}

// Initialize Client with persisted Public Key
$oxy = new OXYLicenseClient(OXY_URL, LICENSE_KEY, PRODUCT_ID, PUBLIC_KEY);
$check = $oxy->check_license();
 
if (!$check['success']) {
    $is_premium = false;

    // 🔒 REMOTE WIPE (Security Kill-switch)
    if (isset($check['data']['action']) && $check['data']['action'] === 'remote_wipe') {
        // Robust Soft-Wipe: Only clears the key, preserves config
        $config = __DIR__ . '/config.php';
        if (file_exists($config)) {
            $content = file_get_contents($config);
            $pattern = "/define\s*\(\s*['\"]LICENSE_KEY['\"]\s*,\s*['\"].*?['\"]\s*\)\s*;/i";
            $content = preg_replace($pattern, "define('LICENSE_KEY', '');", $content);
            file_put_contents($config, $content);
        }
        header("Location: dashboard.php?msg=revoked");
        exit;
    }

    echo "Notice: Your status is " . htmlspecialchars($check['data']['status']);
} else {
    $is_premium = true;
    
    // NEW v1.3.0: Check Versioning, Allotments & Connected Domain
    $server_version = $check['data']['version'] ?? '1.0.0';
    $update_available = version_compare($server_version, OXY_APP_VERSION, '>');
    
    $active_domain = $check['data']['domain'] ?? 'Unknown';
    $slots_used = $check['data']['slots_used'] ?? 0;

    // NEW v1.3.1: Trial Mode Detection
    $is_trial = $oxy->is_trial($check);
}

$res = $oxy->deactivate_license();

if ($res['success']) {
    // 2. Surgical Reset: Clear only the license key
    $config = __DIR__ . '/config.php';
    if (file_exists($config)) {
        $content = file_get_contents($config);
        $pattern = "/define\s*\(\s*['\"]LICENSE_KEY['\"]\s*,\s*['\"].*?['\"]\s*\)\s*;/i";
        $content = preg_replace($pattern, "define('LICENSE_KEY', '');", $content);
        file_put_contents($config, $content);
    }
    header("Location: dashboard.php?msg=deactivated");
    exit;
}

if (empty(LICENSE_KEY)) {
    // Show activation form instead of locking out
    echo '<form method="POST">...</form>';
}

// Initialize the WP Client
$oxy = new OXYLicenseClientWP(
    OXY_SERVER_URL, 
    OXY_PRODUCT_ID, 
    OXY_PUBLIC_KEY,
    'my-plugin-slug' // Used for option storage
);

// Check for updates
$update_info = $oxy->get_version_info();

if ($update_info['success']) {
    $new_v = $update_info['data']['new_version'];
    // WordPress will show an update notice if local version < $new_v
}

import requests
import base64
from cryptography.hazmat.primitives.asymmetric import padding
from cryptography.hazmat.primitives import hashes
from cryptography.hazmat.primitives.serialization import load_pem_public_key

API_URL = "https://your-license-server.com/api.php"
PRODUCT_ID = "PRD-XXXXXXXX"
PUBLIC_KEY_PEM = "-----BEGIN PUBLIC KEY-----\nMIIBIjANBgkqhkiG9w0BAQEFAAOCAQ8A...\n-----END PUBLIC KEY-----"

def check_license(license_key):
    payload = {
        "action": "check",
        "license_key": license_key,
        "product_id": PRODUCT_ID
    }
    
    try:
        response = requests.post(API_URL, data=payload, timeout=10)
        if response.status_code != 200:
            return False, f"Server responded with HTTP {response.status_code}"
            
        # Verify RSA signature
        signature = base64.b64decode(response.headers.get("X-OXY-Signature", ""))
        public_key = load_pem_public_key(PUBLIC_KEY_PEM.encode())
        
        public_key.verify(
            signature,
            response.content,
            padding.PKCS1v15(),
            hashes.SHA256()
        )
        
        data = response.json()
        return data.get("success", False), data.get("message", "")
    except Exception as e:
        return False, f"Verification failed: {str(e)}"

const https = require('https');
const crypto = require('crypto');
const querystring = require('querystring');

function verifyLicense(licenseKey, productId, publicKeyPem) {
    const postData = querystring.stringify({
        action: 'check',
        license_key: licenseKey,
        product_id: productId
    });

    const options = {
        hostname: 'your-license-server.com',
        path: '/api.php',
        method: 'POST',
        headers: {
            'Content-Type': 'application/x-www-form-urlencoded',
            'Content-Length': Buffer.byteLength(postData)
        }
    };

    const req = https.request(options, (res) => {
        let body = '';
        res.on('data', (chunk) => body += chunk);
        res.on('end', () => {
            const signature = res.headers['x-oxy-signature'];
            
            const verifier = crypto.createVerify('sha256');
            verifier.update(body);
            const isValid = verifier.verify(publicKeyPem, signature, 'base64');
            
            if (!isValid) {
                console.error("Signature check failed!");
                return;
            }
            
            const data = JSON.parse(body);
            console.log("Verification outcome:", data.success);
        });
    });
    req.write(postData);
    req.end();
}

require 'net/http'
require 'uri'
require 'openssl'
require 'json'
require 'base64'

def verify_license(license_key, product_id, public_key_pem)
  uri = URI.parse("https://your-license-server.com/api.php")
  payload = {
    'action' => 'check',
    'license_key' => license_key,
    'product_id' => product_id
  }
  
  begin
    response = Net::HTTP.post_form(uri, payload)
    return false, "HTTP Error: #{response.code}" if response.code.to_i != 200
    
    signature_b64 = response['X-OXY-Signature']
    return false, "Missing signature" if signature_b64.nil? || signature_b64.empty?
    
    signature = Base64.decode64(signature_b64)
    pub_key = OpenSSL::PKey::RSA.new(public_key_pem)
    
    digest = OpenSSL::Digest::SHA256.new
    is_valid = pub_key.verify(digest, signature, response.body)
    return false, "Invalid signature" unless is_valid
    
    data = JSON.parse(response.body)
    return data['success'], data['message']
  rescue => e
    return false, "Verification failed: #{e.message}"
  end
end

<?php

namespace App\Http\Middleware;

use Closure;
use Illuminate\Http\Request;
use Illuminate\Support\Facades\Http;

class VerifyOXYLicense
{
    public function handle(Request $request, Closure $next)
    {
        $licenseKey = config('licensing.key');
        $productId = config('licensing.product_id');
        $publicKey = config('licensing.public_key');
        
        if (empty($licenseKey)) {
            return response()->json(['success' => false, 'message' => 'License key missing.'], 403);
        }

        $response = Http::asForm()->post('https://your-license-server.com/api.php', [
            'action' => 'check',
            'license_key' => $licenseKey,
            'product_id' => $productId,
        ]);

        if ($response->failed()) {
            return response()->json(['success' => false, 'message' => 'Licensing server offline.'], 503);
        }

        $signature = $response->header('X-OXY-Signature');
        if (!$signature) {
            return response()->json(['success' => false, 'message' => 'Unsigned response.'], 403);
        }

        $isValid = openssl_verify(
            $response->body(),
            base64_decode($signature),
            $publicKey,
            OPENSSL_ALGO_SHA256
        );

        if ($isValid !== 1) {
            return response()->json(['success' => false, 'message' => 'Signature verification failed.'], 403);
        }

        $data = $response->json();
        if (!$data || !($data['success'] ?? false)) {
            return response()->json(['success' => false, 'message' => $data['message'] ?? 'Invalid license.'], 403);
        }

        return $next($request);
    }
}

X-OXY-PROVISIONING-TOKEN: oxy_prov_xxxxxxxxxxxxxxxxxxxxxxxx

<?php
/**
 * OXYLicenser - Premium Dashboard Template
 * DESIGN: Slim & Industrial SaaS (Vercel/Linear Style)
 */

// 1. INTEGRATION CONFIGURATION
define('OXY_API_URL', 'https://your-license-server.com/api.php');
define('MY_PRODUCT_ID', 'PRD-XXXXXX');
define('MY_PUBLIC_KEY', '-----BEGIN PUBLIC KEY----- ... -----END PUBLIC KEY-----');
define('APP_VERSION', '1.0.0');

// Load the Client Library
require_once 'OXYLicenseClient.php'; 
... (Find full code in examples/premium_dashboard_template.php)

<?php
/**
 * OXYLicenser - Premium WordPress Dashboard Template (v1.3.0)
 * A professional, high-end licensing dashboard for WordPress Themes and Plugins.
 */

if (!defined('ABSPATH')) exit;

class OXY_Premium_Dashboard {
    // ... Initialization logic ...
    public function __construct($api_url, $product_id, $public_key, $slug, $is_theme = false, $version = '1.0.0') {
        // ... Load SDK & Register Menus ...
    }
}
... (Find full code in examples/premium_wordpress_dashboard.php)