Security fixes, enterprise stuff and more (#3241)

# Description of Changes

Please provide a summary of the changes, including:

- Enable user to add custom JAVA ops with env JAVA_CUSTOM_OPTS
- Added support for prometheus (enabled via JAVA_CUSTOM_OPTS +
enterprise license)
- Changed settings from enterprise naming to 'Premium'
- KeygenLicense Check to support offline licenses
- Disable URL-to-PDF due to huge security bug
- Remove loud Split PDF logs
- addUsers renamed to adminSettings
- Added Usage analytics page
- Add user button to only be enabled based on total users free
- Improve Merge memory usage


Closes #(issue_number)

---

## Checklist

### General

- [ ] I have read the [Contribution
Guidelines](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/CONTRIBUTING.md)
- [ ] I have read the [Stirling-PDF Developer
Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/DeveloperGuide.md)
(if applicable)
- [ ] I have read the [How to add new languages to
Stirling-PDF](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/HowToAddNewLanguage.md)
(if applicable)
- [ ] I have performed a self-review of my own code
- [ ] My changes generate no new warnings

### Documentation

- [ ] I have updated relevant docs on [Stirling-PDF's doc
repo](https://github.com/Stirling-Tools/Stirling-Tools.github.io/blob/main/docs/)
(if functionality has heavily changed)
- [ ] I have read the section [Add New Translation
Tags](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/HowToAddNewLanguage.md#add-new-translation-tags)
(for new translation tags only)

### UI Changes (if applicable)

- [ ] Screenshots or videos demonstrating the UI changes are attached
(e.g., as comments or direct attachments in the PR)

### Testing (if applicable)

- [ ] I have tested my changes locally. Refer to the [Testing
Guide](https://github.com/Stirling-Tools/Stirling-PDF/blob/main/DeveloperGuide.md#6-testing)
for more details.

---------

Co-authored-by: a <a>
Co-authored-by: pixeebot[bot] <104101892+pixeebot[bot]@users.noreply.github.com>
Co-authored-by: Connor Yoh <con.yoh13@gmail.com>

src/main/java/stirling/software/SPDF/EE/EEAppConfig.java

@@ -8,6 +8,8 @@ import org.springframework.core.annotation.Order;
 import lombok.extern.slf4j.Slf4j;
 
 import stirling.software.SPDF.model.ApplicationProperties;
+import stirling.software.SPDF.model.ApplicationProperties.EnterpriseEdition;
+import stirling.software.SPDF.model.ApplicationProperties.Premium;
 
 @Configuration
 @Order(Ordered.HIGHEST_PRECEDENCE)
@@ -22,6 +24,7 @@ public class EEAppConfig {
             ApplicationProperties applicationProperties, LicenseKeyChecker licenseKeyChecker) {
         this.applicationProperties = applicationProperties;
         this.licenseKeyChecker = licenseKeyChecker;
+        migrateEnterpriseSettingsToPremium(this.applicationProperties);
     }
 
     @Bean(name = "runningEE")
@@ -31,6 +34,74 @@ public class EEAppConfig {
 
     @Bean(name = "SSOAutoLogin")
     public boolean ssoAutoLogin() {
-        return applicationProperties.getEnterpriseEdition().isSsoAutoLogin();
+        return applicationProperties.getPremium().getProFeatures().isSsoAutoLogin();
+    }
+
+    // TODO: Remove post migration
+    public void migrateEnterpriseSettingsToPremium(ApplicationProperties applicationProperties) {
+        EnterpriseEdition enterpriseEdition = applicationProperties.getEnterpriseEdition();
+        Premium premium = applicationProperties.getPremium();
+
+        // Only proceed if both objects exist
+        if (enterpriseEdition == null || premium == null) {
+            return;
+        }
+
+        // Copy the license key if it's set in enterprise but not in premium
+        if (premium.getKey() == null
+                || premium.getKey().equals("00000000-0000-0000-0000-000000000000")) {
+            if (enterpriseEdition.getKey() != null
+                    && !enterpriseEdition.getKey().equals("00000000-0000-0000-0000-000000000000")) {
+                premium.setKey(enterpriseEdition.getKey());
+            }
+        }
+
+        // Copy enabled state if enterprise is enabled but premium is not
+        if (!premium.isEnabled() && enterpriseEdition.isEnabled()) {
+            premium.setEnabled(true);
+        }
+
+        // Copy SSO auto login setting
+        if (!premium.getProFeatures().isSsoAutoLogin() && enterpriseEdition.isSsoAutoLogin()) {
+            premium.getProFeatures().setSsoAutoLogin(true);
+        }
+
+        // Copy CustomMetadata settings
+        Premium.ProFeatures.CustomMetadata premiumMetadata =
+                premium.getProFeatures().getCustomMetadata();
+        EnterpriseEdition.CustomMetadata enterpriseMetadata = enterpriseEdition.getCustomMetadata();
+
+        if (enterpriseMetadata != null && premiumMetadata != null) {
+            // Copy autoUpdateMetadata setting
+            if (!premiumMetadata.isAutoUpdateMetadata()
+                    && enterpriseMetadata.isAutoUpdateMetadata()) {
+                premiumMetadata.setAutoUpdateMetadata(true);
+            }
+
+            // Copy author if not set in premium but set in enterprise
+            if ((premiumMetadata.getAuthor() == null
+                            || premiumMetadata.getAuthor().trim().isEmpty()
+                            || "username".equals(premiumMetadata.getAuthor()))
+                    && enterpriseMetadata.getAuthor() != null
+                    && !enterpriseMetadata.getAuthor().trim().isEmpty()) {
+                premiumMetadata.setAuthor(enterpriseMetadata.getAuthor());
+            }
+
+            // Copy creator if not set in premium but set in enterprise and different from default
+            if ((premiumMetadata.getCreator() == null
+                            || "Stirling-PDF".equals(premiumMetadata.getCreator()))
+                    && enterpriseMetadata.getCreator() != null
+                    && !"Stirling-PDF".equals(enterpriseMetadata.getCreator())) {
+                premiumMetadata.setCreator(enterpriseMetadata.getCreator());
+            }
+
+            // Copy producer if not set in premium but set in enterprise and different from default
+            if ((premiumMetadata.getProducer() == null
+                            || "Stirling-PDF".equals(premiumMetadata.getProducer()))
+                    && enterpriseMetadata.getProducer() != null
+                    && !"Stirling-PDF".equals(enterpriseMetadata.getProducer())) {
+                premiumMetadata.setProducer(enterpriseMetadata.getProducer());
+            }
+        }
     }
 }

src/main/java/stirling/software/SPDF/EE/KeygenLicenseVerifier.java

@@ -4,12 +4,17 @@ import java.net.URI;
 import java.net.http.HttpClient;
 import java.net.http.HttpRequest;
 import java.net.http.HttpResponse;
+import java.util.Base64;
 
+import org.bouncycastle.crypto.params.Ed25519PublicKeyParameters;
+import org.bouncycastle.crypto.signers.Ed25519Signer;
+import org.bouncycastle.util.encoders.Hex;
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.stereotype.Service;
 
 import com.fasterxml.jackson.databind.JsonNode;
 import com.fasterxml.jackson.databind.ObjectMapper;
+import com.posthog.java.shaded.org.json.JSONException;
 import com.posthog.java.shaded.org.json.JSONObject;
 
 import lombok.extern.slf4j.Slf4j;
@@ -20,11 +25,19 @@ import stirling.software.SPDF.utils.GeneralUtils;
 @Service
 @Slf4j
 public class KeygenLicenseVerifier {
-    // todo: place in config files?
+    // License verification configuration
     private static final String ACCOUNT_ID = "e5430f69-e834-4ae4-befd-b602aae5f372";
     private static final String BASE_URL = "https://api.keygen.sh/v1/accounts";
-    private static final ObjectMapper objectMapper = new ObjectMapper();
 
+    private static final String PUBLIC_KEY =
+            "9fbc0d78593dcfcf03c945146edd60083bf5fae77dbc08aaa3935f03ce94a58d";
+
+    private static final String CERT_PREFIX = "-----BEGIN LICENSE FILE-----";
+    private static final String CERT_SUFFIX = "-----END LICENSE FILE-----";
+
+    private static final String JWT_PREFIX = "key/";
+
+    private static final ObjectMapper objectMapper = new ObjectMapper();
     private final ApplicationProperties applicationProperties;
 
     @Autowired
@@ -32,9 +45,367 @@ public class KeygenLicenseVerifier {
         this.applicationProperties = applicationProperties;
     }
 
-    public boolean verifyLicense(String licenseKey) {
+    public boolean verifyLicense(String licenseKeyOrCert) {
+        if (isCertificateLicense(licenseKeyOrCert)) {
+            log.info("Detected certificate-based license. Processing...");
+            return verifyCertificateLicense(licenseKeyOrCert);
+        } else if (isJWTLicense(licenseKeyOrCert)) {
+            log.info("Detected JWT-style license key. Processing...");
+            return verifyJWTLicense(licenseKeyOrCert);
+        } else {
+            log.info("Detected standard license key. Processing...");
+            return verifyStandardLicense(licenseKeyOrCert);
+        }
+    }
+
+    private boolean isCertificateLicense(String license) {
+        return license != null && license.trim().startsWith(CERT_PREFIX);
+    }
+
+    private boolean isJWTLicense(String license) {
+        return license != null && license.trim().startsWith(JWT_PREFIX);
+    }
+
+    private boolean verifyCertificateLicense(String licenseFile) {
         try {
-            log.info("Checking license key");
+            log.info("Verifying certificate-based license");
+
+            String encodedPayload = licenseFile;
+            // Remove the header
+            encodedPayload = encodedPayload.replace(CERT_PREFIX, "");
+            // Remove the footer
+            encodedPayload = encodedPayload.replace(CERT_SUFFIX, "");
+            // Remove all newlines
+            encodedPayload = encodedPayload.replaceAll("\\r?\\n", "");
+
+            byte[] payloadBytes = Base64.getDecoder().decode(encodedPayload);
+            String payload = new String(payloadBytes);
+
+            log.info("Decoded certificate payload: {}", payload);
+
+            String encryptedData = "";
+            String encodedSignature = "";
+            String algorithm = "";
+
+            try {
+                JSONObject attrs = new JSONObject(payload);
+                encryptedData = (String) attrs.get("enc");
+                encodedSignature = (String) attrs.get("sig");
+                algorithm = (String) attrs.get("alg");
+
+                log.info("Certificate algorithm: {}", algorithm);
+            } catch (JSONException e) {
+                log.error("Failed to parse license file: {}", e.getMessage());
+                return false;
+            }
+
+            // Verify license file algorithm
+            if (!algorithm.equals("base64+ed25519")) {
+                log.error(
+                        "Unsupported algorithm: {}. Only base64+ed25519 is supported.", algorithm);
+                return false;
+            }
+
+            // Verify signature
+            boolean isSignatureValid = verifyEd25519Signature(encryptedData, encodedSignature);
+            if (!isSignatureValid) {
+                log.error("License file signature is invalid");
+                return false;
+            }
+
+            log.info("License file signature is valid");
+
+            // Decode the base64 data
+            String decodedData;
+            try {
+                decodedData = new String(Base64.getDecoder().decode(encryptedData));
+            } catch (IllegalArgumentException e) {
+                log.error("Failed to decode license data: {}", e.getMessage());
+                return false;
+            }
+
+            // Process the certificate data
+            boolean isValid = processCertificateData(decodedData);
+
+            return isValid;
+        } catch (Exception e) {
+            log.error("Error verifying certificate license: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    private boolean verifyEd25519Signature(String encryptedData, String encodedSignature) {
+        try {
+            log.info("Signature to verify: {}", encodedSignature);
+            log.info("Public key being used: {}", PUBLIC_KEY);
+
+            byte[] signatureBytes = Base64.getDecoder().decode(encodedSignature);
+
+            // Create the signing data format - prefix with "license/"
+            String signingData = String.format("license/%s", encryptedData);
+            byte[] signingDataBytes = signingData.getBytes();
+
+            log.info("Signing data length: {} bytes", signingDataBytes.length);
+
+            byte[] publicKeyBytes = Hex.decode(PUBLIC_KEY);
+
+            Ed25519PublicKeyParameters verifierParams =
+                    new Ed25519PublicKeyParameters(publicKeyBytes, 0);
+            Ed25519Signer verifier = new Ed25519Signer();
+
+            verifier.init(false, verifierParams);
+            verifier.update(signingDataBytes, 0, signingDataBytes.length);
+
+            // Verify the signature
+            boolean result = verifier.verifySignature(signatureBytes);
+            if (!result) {
+                log.error("Signature verification failed with standard public key");
+            }
+
+            return result;
+        } catch (Exception e) {
+            log.error("Error verifying Ed25519 signature: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    private boolean processCertificateData(String certData) {
+        try {
+            log.info("Processing certificate data: {}", certData);
+
+            JSONObject licenseData = new JSONObject(certData);
+            JSONObject metaObj = licenseData.optJSONObject("meta");
+            if (metaObj != null) {
+                String issuedStr = metaObj.optString("issued", null);
+                String expiryStr = metaObj.optString("expiry", null);
+
+                if (issuedStr != null && expiryStr != null) {
+                    java.time.Instant issued = java.time.Instant.parse(issuedStr);
+                    java.time.Instant expiry = java.time.Instant.parse(expiryStr);
+                    java.time.Instant now = java.time.Instant.now();
+
+                    if (issued.isAfter(now)) {
+                        log.error(
+                                "License file issued date is in the future. Please adjust system time or request a new license");
+                        return false;
+                    }
+
+                    // Check if the license file has expired
+                    if (expiry.isBefore(now)) {
+                        log.error("License file has expired on {}", expiryStr);
+                        return false;
+                    }
+
+                    log.info("License file valid until {}", expiryStr);
+                }
+            }
+
+            // Get the main license data
+            JSONObject dataObj = licenseData.optJSONObject("data");
+            if (dataObj == null) {
+                log.error("No data object found in certificate");
+                return false;
+            }
+
+            // Extract license or machine information
+            JSONObject attributesObj = dataObj.optJSONObject("attributes");
+            if (attributesObj != null) {
+                log.info("Found attributes in certificate data");
+
+                // Extract metadata
+                JSONObject metadataObj = attributesObj.optJSONObject("metadata");
+                if (metadataObj != null) {
+                    int users = metadataObj.optInt("users", 0);
+                    if (users > 0) {
+                        applicationProperties.getPremium().setMaxUsers(users);
+                        log.info("License allows for {} users", users);
+                    }
+                }
+
+                // Check maxUsers directly in attributes if present from policy definition
+                //                if (attributesObj.has("maxUsers")) {
+                //                    int maxUsers = attributesObj.optInt("maxUsers", 0);
+                //                    if (maxUsers > 0) {
+                //                        applicationProperties.getPremium().setMaxUsers(maxUsers);
+                //                        log.info("License directly specifies {} max users",
+                // maxUsers);
+                //                    }
+                //                }
+
+                // Check license status if available
+                String status = attributesObj.optString("status", null);
+                if (status != null
+                        && !status.equals("ACTIVE")
+                        && !status.equals("EXPIRING")) { // Accept "EXPIRING" status as valid
+                    log.error("License status is not active: {}", status);
+                    return false;
+                }
+            }
+
+            return true;
+        } catch (Exception e) {
+            log.error("Error processing certificate data: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    private boolean verifyJWTLicense(String licenseKey) {
+        try {
+            log.info("Verifying ED25519_SIGN format license key");
+
+            // Remove the "key/" prefix
+            String licenseData = licenseKey.substring(JWT_PREFIX.length());
+
+            // Split into payload and signature
+            String[] parts = licenseData.split("\\.", 2);
+            if (parts.length != 2) {
+                log.error(
+                        "Invalid ED25519_SIGN license format. Expected format: key/payload.signature");
+                return false;
+            }
+
+            String encodedPayload = parts[0];
+            String encodedSignature = parts[1];
+
+            // Verify signature
+            boolean isSignatureValid = verifyJWTSignature(encodedPayload, encodedSignature);
+            if (!isSignatureValid) {
+                log.error("ED25519_SIGN license signature is invalid");
+                return false;
+            }
+
+            log.info("ED25519_SIGN license signature is valid");
+
+            // Decode and process payload - first convert from URL-safe base64 if needed
+            String base64Payload = encodedPayload.replace('-', '+').replace('_', '/');
+            byte[] payloadBytes = Base64.getDecoder().decode(base64Payload);
+            String payload = new String(payloadBytes);
+
+            // Process the license payload
+            boolean isValid = processJWTLicensePayload(payload);
+
+            return isValid;
+        } catch (Exception e) {
+            log.error("Error verifying ED25519_SIGN license: {}", e.getMessage());
+            return false;
+        }
+    }
+
+    private boolean verifyJWTSignature(String encodedPayload, String encodedSignature) {
+        try {
+            // Decode base64 signature
+            byte[] signatureBytes =
+                    Base64.getDecoder()
+                            .decode(encodedSignature.replace('-', '+').replace('_', '/'));
+
+            // For ED25519_SIGN format, the signing data is "key/" + encodedPayload
+            String signingData = String.format("key/%s", encodedPayload);
+            byte[] dataBytes = signingData.getBytes();
+
+            byte[] publicKeyBytes = Hex.decode(PUBLIC_KEY);
+            Ed25519PublicKeyParameters verifierParams =
+                    new Ed25519PublicKeyParameters(publicKeyBytes, 0);
+            Ed25519Signer verifier = new Ed25519Signer();
+
+            verifier.init(false, verifierParams);
+            verifier.update(dataBytes, 0, dataBytes.length);
+
+            // Verify the signature
+            return verifier.verifySignature(signatureBytes);
+        } catch (Exception e) {
+            log.error("Error verifying JWT signature: {}", e.getMessage());
+            return false;
+        }
+    }
+
+    private boolean processJWTLicensePayload(String payload) {
+        try {
+            log.info("Processing license payload: {}", payload);
+
+            JSONObject licenseData = new JSONObject(payload);
+
+            JSONObject licenseObj = licenseData.optJSONObject("license");
+            if (licenseObj == null) {
+                String id = licenseData.optString("id", null);
+                if (id != null) {
+                    log.info("Found license ID: {}", id);
+                    licenseObj = licenseData; // Use the root object as the license object
+                } else {
+                    log.error("License data not found in payload");
+                    return false;
+                }
+            }
+
+            String licenseId = licenseObj.optString("id", "unknown");
+            log.info("Processing license with ID: {}", licenseId);
+
+            // Check expiry date
+            String expiryStr = licenseObj.optString("expiry", null);
+            if (expiryStr != null && !expiryStr.equals("null")) {
+                java.time.Instant expiry = java.time.Instant.parse(expiryStr);
+                java.time.Instant now = java.time.Instant.now();
+
+                if (now.isAfter(expiry)) {
+                    log.error("License has expired on {}", expiryStr);
+                    return false;
+                }
+
+                log.info("License valid until {}", expiryStr);
+            } else {
+                log.info("License has no expiration date");
+            }
+
+            // Extract account, product, policy info
+            JSONObject accountObj = licenseData.optJSONObject("account");
+            if (accountObj != null) {
+                String accountId = accountObj.optString("id", "unknown");
+                log.info("License belongs to account: {}", accountId);
+
+                // Verify this matches your expected account ID
+                if (!ACCOUNT_ID.equals(accountId)) {
+                    log.warn("License account ID does not match expected account ID");
+                    // You might want to fail verification here depending on your requirements
+                }
+            }
+
+            // Extract policy information if available
+            JSONObject policyObj = licenseData.optJSONObject("policy");
+            if (policyObj != null) {
+                String policyId = policyObj.optString("id", "unknown");
+                log.info("License uses policy: {}", policyId);
+
+                // Extract max users from policy if available (customize based on your policy
+                // structure)
+                int users = policyObj.optInt("users", 0);
+                if (users > 0) {
+                    applicationProperties.getPremium().setMaxUsers(users);
+                    log.info("License allows for {} users", users);
+                } else {
+                    // Try to get users from metadata if present
+                    Object metadataObj = policyObj.opt("metadata");
+                    if (metadataObj instanceof JSONObject) {
+                        JSONObject metadata = (JSONObject) metadataObj;
+                        users = metadata.optInt("users", 1);
+                        applicationProperties.getPremium().setMaxUsers(users);
+                        log.info("License allows for {} users (from metadata)", users);
+                    } else {
+                        // Default value
+                        applicationProperties.getPremium().setMaxUsers(1);
+                        log.info("Using default of 1 user for license");
+                    }
+                }
+            }
+
+            return true;
+        } catch (Exception e) {
+            log.error("Error processing license payload: {}", e.getMessage(), e);
+            return false;
+        }
+    }
+
+    private boolean verifyStandardLicense(String licenseKey) {
+        try {
+            log.info("Checking standard license key");
             String machineFingerprint = generateMachineFingerprint();
 
             // First, try to validate the license
@@ -44,7 +415,7 @@ public class KeygenLicenseVerifier {
                 String licenseId = validationResponse.path("data").path("id").asText();
                 if (!isValid) {
                     String code = validationResponse.path("meta").path("code").asText();
-                    log.debug(code);
+                    log.info(code);
                     if ("NO_MACHINE".equals(code)
                             || "NO_MACHINES".equals(code)
                             || "FINGERPRINT_SCOPE_MISMATCH".equals(code)) {
@@ -69,7 +440,7 @@ public class KeygenLicenseVerifier {
 
             return false;
         } catch (Exception e) {
-            log.error("Error verifying license: {}", e.getMessage());
+            log.error("Error verifying standard license: {}", e.getMessage());
             return false;
         }
     }
@@ -96,7 +467,7 @@ public class KeygenLicenseVerifier {
                         .build();
 
         HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
-        log.debug("ValidateLicenseResponse body: {}", response.body());
+        log.info("ValidateLicenseResponse body: {}", response.body());
         JsonNode jsonResponse = objectMapper.readTree(response.body());
         if (response.statusCode() == 200) {
             JsonNode metaNode = jsonResponse.path("meta");
@@ -105,9 +476,9 @@ public class KeygenLicenseVerifier {
             String detail = metaNode.path("detail").asText();
             String code = metaNode.path("code").asText();
 
-            log.debug("License validity: " + isValid);
-            log.debug("Validation detail: " + detail);
-            log.debug("Validation code: " + code);
+            log.info("License validity: " + isValid);
+            log.info("Validation detail: " + detail);
+            log.info("Validation code: " + code);
 
             int users =
                     jsonResponse
@@ -116,7 +487,7 @@ public class KeygenLicenseVerifier {
                             .path("metadata")
                             .path("users")
                             .asInt(0);
-            applicationProperties.getEnterpriseEdition().setMaxUsers(users);
+            applicationProperties.getPremium().setMaxUsers(users);
             log.info(applicationProperties.toString());
 
         } else {
@@ -148,13 +519,8 @@ public class KeygenLicenseVerifier {
                                                         .put("fingerprint", machineFingerprint)
                                                         .put(
                                                                 "platform",
-                                                                System.getProperty(
-                                                                        "os.name")) // Added
-                                                        // platform
-                                                        // parameter
-                                                        .put(
-                                                                "name",
-                                                                hostname)) // Added name parameter
+                                                                System.getProperty("os.name"))
+                                                        .put("name", hostname))
                                         .put(
                                                 "relationships",
                                                 new JSONObject()
@@ -176,16 +542,12 @@ public class KeygenLicenseVerifier {
                         .uri(URI.create(BASE_URL + "/" + ACCOUNT_ID + "/machines"))
                         .header("Content-Type", "application/vnd.api+json")
                         .header("Accept", "application/vnd.api+json")
-                        .header(
-                                "Authorization",
-                                "License " + licenseKey) // Keep the license key authentication
-                        .POST(
-                                HttpRequest.BodyPublishers.ofString(
-                                        body.toString())) // Send the JSON body
+                        .header("Authorization", "License " + licenseKey)
+                        .POST(HttpRequest.BodyPublishers.ofString(body.toString()))
                         .build();
 
         HttpResponse<String> response = client.send(request, HttpResponse.BodyHandlers.ofString());
-        log.debug("activateMachine Response body: " + response.body());
+        log.info("activateMachine Response body: " + response.body());
         if (response.statusCode() == 201) {
             log.info("Machine activated successfully");
             return true;

src/main/java/stirling/software/SPDF/EE/LicenseKeyChecker.java

@@ -1,6 +1,9 @@
 package stirling.software.SPDF.EE;
 
 import java.io.IOException;
+import java.nio.file.Files;
+import java.nio.file.Path;
+import java.nio.file.Paths;
 
 import org.springframework.beans.factory.annotation.Autowired;
 import org.springframework.scheduling.annotation.Scheduled;
@@ -15,11 +18,13 @@ import stirling.software.SPDF.utils.GeneralUtils;
 @Slf4j
 public class LicenseKeyChecker {
 
+    private static final String FILE_PREFIX = "file:";
+
     private final KeygenLicenseVerifier licenseService;
 
     private final ApplicationProperties applicationProperties;
 
-    private boolean enterpriseEnabledResult = false;
+    private boolean premiumEnabledResult = false;
 
     @Autowired
     public LicenseKeyChecker(
@@ -35,27 +40,58 @@ public class LicenseKeyChecker {
     }
 
     private void checkLicense() {
-        if (!applicationProperties.getEnterpriseEdition().isEnabled()) {
-            enterpriseEnabledResult = false;
+        if (!applicationProperties.getPremium().isEnabled()) {
+            premiumEnabledResult = false;
         } else {
-            enterpriseEnabledResult =
-                    licenseService.verifyLicense(
-                            applicationProperties.getEnterpriseEdition().getKey());
-            if (enterpriseEnabledResult) {
-                log.info("License key is valid.");
+            String licenseKey = getLicenseKeyContent(applicationProperties.getPremium().getKey());
+            if (licenseKey != null) {
+                premiumEnabledResult = licenseService.verifyLicense(licenseKey);
+                if (premiumEnabledResult) {
+                    log.info("License key is valid.");
+                } else {
+                    log.info("License key is invalid.");
+                }
             } else {
-                log.info("License key is invalid.");
+                log.error("Failed to obtain license key content.");
+                premiumEnabledResult = false;
             }
         }
     }
 
+    private String getLicenseKeyContent(String keyOrFilePath) {
+        if (keyOrFilePath == null || keyOrFilePath.trim().isEmpty()) {
+            log.error("License key is not specified");
+            return null;
+        }
+
+        // Check if it's a file reference
+        if (keyOrFilePath.startsWith(FILE_PREFIX)) {
+            String filePath = keyOrFilePath.substring(FILE_PREFIX.length());
+            try {
+                Path path = Paths.get(filePath);
+                if (!Files.exists(path)) {
+                    log.error("License file does not exist: {}", filePath);
+                    return null;
+                }
+                log.info("Reading license from file: {}", filePath);
+                return Files.readString(path);
+            } catch (IOException e) {
+                log.error("Failed to read license file: {}", e.getMessage());
+                return null;
+            }
+        }
+
+        // It's a direct license key
+        return keyOrFilePath;
+    }
+
     public void updateLicenseKey(String newKey) throws IOException {
-        applicationProperties.getEnterpriseEdition().setKey(newKey);
+        applicationProperties.getPremium().setKey(newKey);
         GeneralUtils.saveKeyToSettings("EnterpriseEdition.key", newKey);
         checkLicense();
     }
 
     public boolean getEnterpriseEnabledResult() {
-        return enterpriseEnabledResult;
+        return premiumEnabledResult;
     }
 }