import java.net.URI;
import java.net.http.HttpClient;
import java.net.http.HttpRequest;
import java.net.http.HttpResponse;
import java.time.Duration;

public class KryptLicenseGuard {

    // Calls the Krypt DRM API and returns true (Valid) or false (Blocked/Invalid)
    public static boolean verifyLicense(String serverUrl, String licenseKey, String productId) {
        try {
            String jsonPayload = "{\"license_key\":\"" + licenseKey + "\",\"product_id\":\"" + productId + "\"}";
            HttpClient client = HttpClient.newBuilder().connectTimeout(Duration.ofSeconds(5)).build();

            HttpRequest request = HttpRequest.newBuilder()
                .uri(URI.create(serverUrl + "/api/v1/license/verify"))
                .header("Content-Type", "application/json")
                .timeout(Duration.ofSeconds(5))
                .POST(HttpRequest.BodyPublishers.ofString(jsonPayload))
                .build();

            HttpResponse response = client.send(request, HttpResponse.BodyHandlers.ofString());
            return response.statusCode() == 200 && response.body().contains("\"valid\":true");
        } catch (Exception e) {
            System.err.println("[Krypt] License check error: " + e.getMessage());
            return false; // License server unreachable or error -> Don't start!
        }
    }
}

// ----------------------------------------------------
// Example: Inside your JavaPlugin onEnable() method:
// ----------------------------------------------------
/*
@Override
public void onEnable() {
    String licenseKey = getConfig().getString("license-key");
    boolean isValid = KryptLicenseGuard.verifyLicense("http://localhost:3000", licenseKey, "krypt-core");

    if (isValid) {
        getLogger().info("✅ License verified successfully! Starting plugin...");
        // Start your plugin features here
    } else {
        getLogger().severe("❌ Invalid or blocked license! Disabling plugin...");
        getServer().getPluginManager().disablePlugin(this); // Shuts down plugin!
        return; // Don't start the thing!
    }
}
*/

import requests
import sys

def verify_krypt_license(server_url: str, license_key: str, product_id: str) -> bool:
    try:
        url = f"{server_url}/api/v1/license/verify"
        response = requests.post(url, json={
            "license_key": license_key,
            "product_id": product_id,
            "version": "1.0.0"
        }, timeout=5)
        
        data = response.json()
        return data.get("valid") is True
    except Exception as e:
        print(f"[Krypt] Error contacting license server: {e}")
        return False

# ----------------------------------------------------
# Main Startup Check
# ----------------------------------------------------
LICENSE_KEY = "KRYPT-XXXX-XXXX-XXXX"
PRODUCT_ID = "krypt-core"
SERVER_URL = "http://localhost:3000"

if verify_krypt_license(SERVER_URL, LICENSE_KEY, PRODUCT_ID):
    print("✅ License Verified! Launching application...")
    # START YOUR PROGRAM HERE
else:
    print("❌ Invalid or expired license! Exiting...")
    sys.exit(1) # DONT START THE THING!

async function verifyLicense(serverUrl, licenseKey, productId) {
  try {
    const res = await fetch(`${serverUrl}/api/v1/license/verify`, {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ license_key: licenseKey, product_id: productId })
    });
    const data = await res.json();
    return data.valid === true;
  } catch (err) {
    console.error('[Krypt] License check failed:', err.message);
    return false;
  }
}

// ----------------------------------------------------
// Startup Guard
// ----------------------------------------------------
(async () => {
  const isValid = await verifyLicense('http://localhost:3000', process.env.LICENSE_KEY || 'KRYPT-XXXX', 'krypt-core');
  
  if (isValid) {
    console.log('✅ License valid! Starting application...');
    // START YOUR APP / BOT / SERVER HERE
  } else {
    console.error('❌ License verification failed! Terminating...');
    process.exit(1); // DONT START THE THING!
  }
})();

using System;
using System.Net.Http;
using System.Text;
using System.Threading.Tasks;

public class KryptGuard
{
    private static readonly HttpClient client = new HttpClient();

    public static async Task VerifyLicenseAsync(string serverUrl, string licenseKey, string productId)
    {
        try
        {
            var json = $"{{\"license_key\":\"{licenseKey}\",\"product_id\":\"{productId}\"}}";
            var content = new StringContent(json, Encoding.UTF8, "application/json");

            var response = await client.PostAsync($"{serverUrl}/api/v1/license/verify", content);
            var responseString = await response.Content.ReadAsStringAsync();

            return response.IsSuccessStatusCode && responseString.Contains("\"valid\":true");
        }
        catch (Exception)
        {
            return false;
        }
    }
}

// ----------------------------------------------------
// Startup Check
// ----------------------------------------------------
/*
bool isValid = await KryptGuard.VerifyLicenseAsync("http://localhost:3000", "KRYPT-XXXX", "krypt-core");
if (isValid) {
    // Start application
} else {
    Environment.Exit(1); // DONT START THE THING!
}
*/

use serde_json::json;

#[tokio::main]
async fn main() {
    let is_valid = verify_license("http://localhost:3000", "KRYPT-XXXX", "krypt-core").await;
    
    if is_valid {
        println!("✅ License valid! Starting program...");
        // Start your software
    } else {
        eprintln!("❌ License verification failed! Exiting...");
        std::process::exit(1); // DONT START THE THING!
    }
}

async fn verify_license(server_url: &str, license_key: &str, product_id: &str) -> bool {
    let client = reqwest::Client::new();
    let res = client.post(format!("{}/api/v1/license/verify", server_url))
        .json(&json!({ "license_key": license_key, "product_id": product_id }))
        .send()
        .await;

    match res {
        Ok(response) => {
            if let Ok(text) = response.text().await {
                text.contains("\"valid\":true")
            } else { false }
        },
        Err(_) => false
    }
}

package main

import (
	"bytes"
	"encoding/json"
	"io"
	"log"
	"net/http"
	"strings"
	"time"
)

func verifyLicense(serverUrl, licenseKey, productId string) bool {
	payload, _ := json.Marshal(map[string]string{
		"license_key": licenseKey,
		"product_id":  productId,
	})

	client := &http.Client{Timeout: 5 * time.Second}
	resp, err := client.Post(serverUrl+"/api/v1/license/verify", "application/json", bytes.NewBuffer(payload))
	if err != nil || resp.StatusCode != 200 {
		return false
	}
	defer resp.Body.Close()

	body, _ := io.ReadAll(resp.Body)
	return strings.Contains(string(body), `"valid":true`)
}

func main() {
	if !verifyLicense("http://localhost:3000", "KRYPT-XXXX", "krypt-core") {
		log.Fatalf("❌ License check failed! Aborting...") // DONT START THE THING!
	}

	log.Println("✅ License valid! Starting daemon...")
	// Start your service
}

# Direct cURL License Verification (POST)
curl -s -X POST http://localhost:3000/api/v1/license/verify \
  -H "Content-Type: application/json" \
  -d '{
    "license_key": "KRYPT-XXXX-XXXX-XXXX",
    "product_id": "krypt-core"
  }' | grep '"valid":true' > /dev/null

if [ $? -eq 0 ]; then
  echo "✅ License Valid! Starting software..."
  # ./start_my_software.sh
else
  echo "❌ License Verification Failed! Exiting..."
  exit 1 # DONT START THE THING!
fi