ExisOne.Client 0.4.0

Software Activation System

A comprehensive software licensing and activation system built with .NET 8, Entity Framework Core, and SQL Server.

Features

• Product management with versioning
• License generation and activation
• Hardware-locked licensing
• License validation and expiration
• License deactivation
• License history tracking
• Admin dashboard for license management

Project Structure

• SoftwareActivationSystem.Api: ASP.NET Core Web API project containing the license management system
• SoftwareActivationSystem.Core: Core library containing shared interfaces and models
• SoftwareActivationSystem.HardwareId: Library for generating unique hardware IDs

Setup

1. Update the database connection string in appsettings.json with your Azure SQL Database credentials:

{
  "ConnectionStrings": {
    "DefaultConnection": "Server=exiswwwdb.database.windows.net;Database=exiswwwdb;User Id=your_username;Password=your_password;"
  }
}

2. Build and run the solution:

dotnet build
dotnet run --project SoftwareActivationSystem.Api

3. Access the web interface at https://localhost:5001 to generate activation keys.

API Endpoints

Products

• GET /api/products - Get all products
• GET /api/products/{id} - Get a specific product
• POST /api/products - Create a new product
• PUT /api/products/{id} - Update a product
• DELETE /api/products/{id} - Delete a product

Activation Keys

• POST /api/activationkey/generate - Generate a new activation key

  {
    "productName": "string",
    "email": "string",
    "validityDays": number
  }
  

Licenses

• GET /api/license - Get all licenses
• POST /api/license/activate - Activate a license

  {
    "activationKey": "string",
    "email": "string",
    "hardwareId": "string",
    "productName": "string"
  }
  

• POST /api/license/validate - Validate a license

  {
    "activationKey": "string",
    "hardwareId": "string"
  }
  

• POST /api/license/check - Check if a license is valid

  {
    "activationKey": "string",
    "hardwareId": "string"
  }
  

• POST /api/license/deactivate - Deactivate a license

  {
    "licenseKey": "string",
    "productName": "string",
    "hardwareId": "string"
  }
  

• PUT /api/license/{activationKey}/expiration - Update license expiration date

  {
    "expirationDate": "2023-12-31T23:59:59Z"
  }
  

• GET /api/license/{activationKey}/history - Get license history

Integration Guide

1. Hardware ID Generation

public static string GetHardwareId()
{
    var cpuId = GetCpuId();
    var motherboardId = GetMotherboardId();
    var diskId = GetDiskId();
    
    // Combine and hash the hardware IDs
    var combinedId = $"{cpuId}|{motherboardId}|{diskId}";
    using (var sha256 = SHA256.Create())
    {
        var hash = sha256.ComputeHash(Encoding.UTF8.GetBytes(combinedId));
        return BitConverter.ToString(hash).Replace("-", "").Substring(0, 32);
    }
}

private static string GetCpuId()
{
    try
    {
        var mbs = new ManagementObjectSearcher("Select ProcessorId From Win32_processor");
        var mbsList = mbs.Get();
        foreach (var mo in mbsList)
        {
            return mo["ProcessorId"].ToString();
        }
    }
    catch { }
    return string.Empty;
}

private static string GetMotherboardId()
{
    try
    {
        var mbs = new ManagementObjectSearcher("Select SerialNumber From Win32_BaseBoard");
        var mbsList = mbs.Get();
        foreach (var mo in mbsList)
        {
            return mo["SerialNumber"].ToString();
        }
    }
    catch { }
    return string.Empty;
}

private static string GetDiskId()
{
    try
    {
        var mbs = new ManagementObjectSearcher("Select SerialNumber From Win32_DiskDrive");
        var mbsList = mbs.Get();
        foreach (var mo in mbsList)
        {
            return mo["SerialNumber"].ToString();
        }
    }
    catch { }
    return string.Empty;
}

2. License Activation

public async Task<License> ActivateLicenseAsync(string activationKey, string email)
{
    var hardwareId = GetHardwareId();
    
    using (var client = new HttpClient())
    {
        client.BaseAddress = new Uri("https://xmis.azurewebsites.net/");
        
        var request = new
        {
            ActivationKey = activationKey,
            Email = email,
            HardwareId = hardwareId,
            ProductName = "YourProductName" // Replace with your product name
        };
        
        var response = await client.PostAsJsonAsync("api/license/activate", request);
        
        if (response.IsSuccessStatusCode)
        {
            return await response.Content.ReadFromJsonAsync<License>();
        }
        
        var error = await response.Content.ReadAsStringAsync();
        throw new Exception($"Activation failed: {error}");
    }
}

3. License Validation

public async Task<bool> ValidateLicenseAsync(string activationKey)
{
    var hardwareId = GetHardwareId();
    
    using (var client = new HttpClient())
    {
        client.BaseAddress = new Uri("https://xmis.azurewebsites.net/");
        
        var request = new
        {
            ActivationKey = activationKey,
            HardwareId = hardwareId
        };
        
        var response = await client.PostAsJsonAsync("api/license/validate", request);
        
        if (response.IsSuccessStatusCode)
        {
            var result = await response.Content.ReadFromJsonAsync<ValidationResult>();
            return result.IsValid;
        }
        
        return false;
    }
}

4. License Deactivation

public async Task<bool> DeactivateLicenseAsync(string licenseKey, string productName, string hardwareId)
{
    using (var client = new HttpClient())
    {
        client.BaseAddress = new Uri("https://xmis.azurewebsites.net/");
        
        var request = new
        {
            LicenseKey = licenseKey,
            ProductName = productName,
            HardwareId = hardwareId
        };
        
        var response = await client.PostAsJsonAsync("api/license/deactivate", request);
        
        if (response.IsSuccessStatusCode)
        {
            return true;
        }
        
        var error = await response.Content.ReadAsStringAsync();
        throw new Exception($"Deactivation failed: {error}");
    }
}

License Service Implementation

public class LicenseService
{
    private readonly HttpClient _httpClient;
    private readonly string _baseUrl = "https://xmis.azurewebsites.net/";
    
    public LicenseService()
    {
        _httpClient = new HttpClient
        {
            BaseAddress = new Uri(_baseUrl)
        };
    }
    
    public async Task<License> ActivateLicenseAsync(string activationKey, string email)
    {
        var hardwareId = GetHardwareId();
        
        var request = new
        {
            ActivationKey = activationKey,
            Email = email,
            HardwareId = hardwareId,
            ProductName = "YourProductName" // Replace with your product name
        };
        
        var response = await _httpClient.PostAsJsonAsync("api/license/activate", request);
        
        if (response.IsSuccessStatusCode)
        {
            return await response.Content.ReadFromJsonAsync<License>();
        }
        
        var error = await response.Content.ReadAsStringAsync();
        throw new Exception($"Activation failed: {error}");
    }
    
    public async Task<bool> ValidateLicenseAsync(string activationKey)
    {
        var hardwareId = GetHardwareId();
        
        var request = new
        {
            ActivationKey = activationKey,
            HardwareId = hardwareId
        };
        
        var response = await _httpClient.PostAsJsonAsync("api/license/validate", request);
        
        if (response.IsSuccessStatusCode)
        {
            var result = await response.Content.ReadFromJsonAsync<ValidationResult>();
            return result.IsValid;
        }
        
        return false;
    }
    
    public async Task<bool> DeactivateLicenseAsync(string licenseKey)
    {
        var request = new
        {
            LicenseKey = licenseKey,
            ProductName = "YourProductName" // Replace with your product name
        };
        
        var response = await _httpClient.PostAsJsonAsync("api/license/deactivate", request);
        
        if (response.IsSuccessStatusCode)
        {
            return true;
        }
        
        var error = await response.Content.ReadAsStringAsync();
        throw new Exception($"Deactivation failed: {error}");
    }
    
    private static string GetHardwareId()
    {
        // Implementation as shown above
    }
}

License Models

public class License
{
    public string ActivationKey { get; set; }
    public string Email { get; set; }
    public string HardwareId { get; set; }
    public DateTime? ActivationDate { get; set; }
    public DateTime ExpirationDate { get; set; }
    public bool IsActive { get; set; }
    public string ProductName { get; set; }
    public string Version { get; set; }
}

public class ValidationResult
{
    public bool IsValid { get; set; }
}

License History

public class LicenseHistory
{
    public int Id { get; set; }
    public string ActivationKey { get; set; }
    public string Email { get; set; }
    public string HardwareId { get; set; }
    public string? IpAddress { get; set; }
    public string? Country { get; set; }
    public DateTime ActivationDate { get; set; }
    public DateTime? DeactivationDate { get; set; }
    public string Action { get; set; }
    public string Notes { get; set; }
    public DateTime CreatedAt { get; set; }
}

.NET Client SDK (NuGet)

Package: ExisOne.Client (version 0.3.0)

Install:

dotnet add package ExisOne.Client --version 0.3.0

Usage:

var options = new ExisOneClientOptions { BaseUrl = "https://your-api/" };
var client = new ExisOneClient(options);

// Generate hardware ID
var hardwareId = client.GenerateHardwareId();

// Activate
await client.ActivateAsync(activationKey, email, hardwareId, productName);

// Validate
var isValid = await client.ValidateAsync(activationKey, hardwareId);

// Deactivate (requires same hardwareId)
var ok = await client.DeactivateAsync(activationKey, hardwareId, productName);

Getting Started

1. Clone the repository
2. Update the connection string in appsettings.json
3. Run the migrations: dotnet ef database update
4. Run the application: dotnet run

Admin Dashboard

Access the admin dashboard at /admin to manage products, licenses, and activation keys.

License

This project is licensed under the MIT License - see the LICENSE file for details.