using System;

using System.Security.Cryptography;

using System.Text;

using System.Text.RegularExpressions;

using Serilog;

​

// Define a class to represent license validation results

public enum LicenseValidationResult

{

    Valid,

    InvalidFormat,

    InvalidSignature,

    Expired,

    Revoked,

    ServerError

}

​

public class LicenseManager

{

    private const string PublicKey = "<RSAKeyValue><Modulus>MIIBIjANB...</Modulus><Exponent>AQAB</Exponent></RSAKeyValue>";

    private const string ValidServerResponse = "VALID";

    private const string InvalidServerResponse = "INVALID";

​

    // Initialize the logger

    private static readonly ILogger _logger = new LoggerConfiguration()

        .MinimumLevel.Debug()

        .WriteTo.Console()

        .WriteTo.File("license_validation.log")

        .CreateLogger();

​

    // Method to validate the license format

    public static bool CheckLicenseFormat(string licenseKey)

    {

        // Check for null or empty license key

        if (string.IsNullOrEmpty(licenseKey))

        {

            _logger.Error("License key cannot be empty.");

            return false;

        }

​

        // Regular expression pattern for license key format

        // This pattern checks for a specific format: XXXX-XXXX-XXXX-XXXX

        // Where X is a letter (A-Z) or a digit (0-9)

        string pattern = @"^[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}-[A-Z0-9]{4}$";

​

        // Check if the license key matches the pattern

        if (!Regex.IsMatch(licenseKey, pattern))

        {

            _logger.Error("Invalid license key format.");

            return false;

        }

​

        return true;

    }

​

    // Method to validate the license signature

    public static bool ValidateLicense(string licenseKey, string signature)

    {

        // Check for null or empty license key and signature

        if (string.IsNullOrEmpty(licenseKey) || string.IsNullOrEmpty(signature))

        {

            _logger.Error("License key and signature cannot be empty.");

            return false;

        }

​

        try

        {

            // Create an RSA crypto service provider

            RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();

​

            // Load the public key

            rsa.FromXmlString(PublicKey);

​

            // Convert the license key to bytes

            byte[] data = Encoding.UTF8.GetBytes(licenseKey);

​

            // Convert the signature to bytes

            byte[] signatureBytes = Convert.FromBase64String(signature);

​

            // Verify the data using the SHA256 algorithm

            return rsa.VerifyData(data, CryptoConfig.MapNameToOID("SHA256"), signatureBytes);

        }

        catch (Exception ex)

        {

            _logger.Error(ex, "Validation error");

            return false;

        }

    }

​

    // Method to validate the license with the server

    public static LicenseValidationResult ValidateLicenseWithServer(string licenseKey)

    {

        try

        {

            // Simulate server validation (replace with actual server call)

            string serverResponse = SimulateServerValidation(licenseKey);

​

            // Check the server response

            if (serverResponse == ValidServerResponse)

            {

                return LicenseValidationResult.Valid;

            }

            else if (serverResponse == "EXPIRED")

            {

                _logger.Error("License has expired.");

                return LicenseValidationResult.Expired;

            }

            else if (serverResponse == "REVOKED")

            {

                _logger.Error("License has been revoked.");

                return LicenseValidationResult.Revoked;

            }

            else

            {

                _logger.Error("Invalid server response.");

                return LicenseValidationResult.InvalidSignature;

            }

        }

        catch (Exception ex)

        {

            _logger.Error(ex, "Server validation error");

            return LicenseValidationResult.ServerError;

        }

    }

​

    // Simulate server validation (replace with actual server call)

    private static string SimulateServerValidation(string licenseKey)

    {

        // Simulate server validation logic here

        // For demonstration purposes, assume the license key is valid

        return ValidServerResponse;

    }

​

    public static void Main()

    {

        string licenseKey = "ABCD-EFGH-IJKL-MNOP";

        string signature = "InvalidBase64Signature==";

​

        if (!CheckLicenseFormat(licenseKey))

        {

            _logger.Error("Invalid license key format.");

            return;

        }

​

        if (!ValidateLicense(licenseKey, signature))

        {

            _logger.Error("License validation failed.");

            return;

        }

​

        LicenseValidationResult result = ValidateLicenseWithServer(licenseKey);

​

        switch (result)

        {

            case LicenseValidationResult.Valid:

                _logger.Information("License successfully validated. Welcome!");

                break;

            case LicenseValidationResult.InvalidFormat:

                _logger.Error("Invalid license key format.");

                break;

            case LicenseValidationResult.InvalidSignature:

                _logger.Error("License validation failed.");

                break;

            case LicenseValidationResult.Expired:

                _logger.Error("License has expired.");

                break;

            case LicenseValidationResult.Revoked:

                _logger.Error("License has been revoked.");

                break;

            case LicenseValidationResult.ServerError:

                _logger.Error("Server validation error.");

                break;

        }

    }

}