License Restrictions

The Restrictions section in a Babel Licensing template allows you to define specific constraints on how licenses can be used. These restrictions provide granular control over license behavior, enabling you to implement various licensing models and enforce usage conditions. Babel Licensing offers several built-in restriction types along with the ability to create custom restrictions.

Overview of License Restrictions

License restrictions serve as enforceable conditions that determine how, when, and where your software can be used under a specific license. Each restriction type addresses a specific aspect of license control, from time-limited usage to hardware binding. Multiple restrictions can be combined within a single license template to create sophisticated licensing models tailored to your specific requirements.

When a license has multiple restrictions, ALL restrictions must be individually validated for the license to be considered valid. If even one restriction fails validation, the entire license validation process will fail. This allows for creating highly specific licensing conditions where all defined constraints must be satisfied simultaneously.

Beta Restriction

The Beta restriction is designed for pre-release software, tagging licenses with information that indicates the software is in beta status.

Key Properties:

• Build Type: Specifies the build type (e.g., "Alpha", "Beta", "RC") to indicate the development stage of the software.

• Recent Changes: A text field where you can document changes or features specific to this beta release.

Use Cases:

• Distributing early access versions to testers or select customers

• Time-limited beta programs before full product release

• Limiting liability by clearly identifying software as pre-release

Implementation Example:

if (license.Restrictions.OfType<BetaRestriction>().Any())
{
    // Show beta warning dialog
    // Enable telemetry and crash reporting
}

Hardware Restriction

The Hardware restriction binds a license to specific hardware, preventing unauthorized use on different machines. This is achieved through a hardware key generated from the target computer's unique characteristics.

Key Properties:

• Hardware Key: A unique identifier generated from hardware components of the machine (can be empty in the template and filled during license activation).

• Data: Additional data that can be used to store hardware-specific information.

Use Cases:

• Single-machine perpetual licenses

• Preventing license sharing across multiple devices

• High-security environments where software must be bound to authorized hardware

Note: When using activation licenses, the hardware restriction is automatically applied during the activation process, as the license becomes bound to the specific machine through its hardware ID. Therefore, it is not necessary to explicitly add a hardware restriction to license templates that use the activation licensing mode. The activation process itself handles the hardware binding functionality.

Trial Restriction

The Trial restriction limits software usage based on time or execution parameters, making it ideal for implementing free trial versions of your software.

Key Properties:

• Expire Days: Number of days the trial is valid after first use.

• Run Instances: Maximum number of concurrent instances allowed.

• Run Count: Maximum total number of application executions allowed.

• Run Time: Maximum duration the application can run per session.

• Terms: Special terms and conditions that apply to the trial license.

Use Cases:

• Time-limited evaluation versions

• Feature-limited trial versions

• Usage-count limited demo versions

• Freemium model implementation

Implementation Example:

var trial = license.Restrictions.OfType<TrialRestriction>().FirstOrDefault();
if (trial != null)
{
    if (trial.IsExpired())
    {
        // Show trial expiration message
        // Prompt for license purchase
    }
    else
    {
        // Show remaining trial period
        // Log trial usage
    }
}

Domain Restriction

The Domain restriction limits license usage to a specific network domain, ensuring that software can only be used within authorized organizational boundaries.

Key Properties:

• Domain: The network domain name where the license is valid (e.g., "example.com").

• Role: Optional role identifier within the domain (e.g., "developer", "admin").

Use Cases:

• Enterprise licensing for specific organizations

• Limiting software use to authorized corporate networks

• Different licensing terms for different organizational units

Usage Restriction

The Usage restriction defines the environment where the application is allowed to run, providing control over deployment scenarios and execution contexts.

Key Properties:

• Usage: Identifies the allowed usage environment or context.

• Can Run In Virtual Environment: When true, allows the software to run in virtualized environments.

• Process List: A list of processes that must or must not be running for the license to be valid.

Use Cases:

• Preventing execution in virtual machines for security-sensitive applications

• Limiting software to specific environments (development, staging, production)

• Requiring or prohibiting the presence of specific companion processes

Custom Restrictions

Beyond the built-in restrictions, Babel Licensing allows you to create custom restrictions to address unique licensing requirements specific to your application. Custom restrictions are powerful extensions that enable you to implement specialized validation logic tailored to your specific business and technical needs.

Implementing Custom Restrictions

To create a custom restriction, you need to implement a class that inherits from Restriction and implements the ILicenseSerializable interface. This gives you complete control over both the validation logic and how the restriction is serialized in the license file.

Key Components of a Custom Restriction:

1. Name Property: A unique identifier for your restriction type.

2. Custom Properties: Properties specific to your restriction's functionality.

3. Validation Logic: Custom code that determines whether the license is valid based on your criteria.

4. Serialization Methods: Methods to read and write your restriction data to XML or format.

Example: Memory Requirements Restriction

Here's an example of a custom restriction that validates whether a machine meets minimum memory requirements.

/// <summary>
/// A license restriction that limits usage based on the physical memory (RAM) 
/// of the system.
/// </summary>
class MemoryRestriction : Restriction, ILicenseSerializable
{
    /// <summary>
    /// Gets the name of the restriction.
    /// </summary>
    public override string Name => "Memory";

    /// <summary>
    /// Gets or sets the minimum total memory required in megabytes.
    /// </summary>
    public long TotalMemory { get; set; }

    /// <summary>
    /// Initializes a new instance of the <see cref="MemoryRestriction"/> class.
    /// </summary>
    public MemoryRestriction()
    {
    }

    /// <summary>
    /// Validates that the system has at least the required amount of physical memory.
    /// </summary>
    /// <param name="context">The license context.</param>
    /// <param name="type">The type being validated.</param>
    /// <param name="instance">The instance being validated.</param>
    /// <returns>A <see cref="ValidationResult"/> indicating whether validation was successful.</returns>
    public override ValidationResult Validate(ILicenseContext context, Type type, object instance)
    {
        ISystemInformation sys = (ISystemInformation)context.GetService(typeof(ISystemInformation));

        // Cannot run on this machine
        long totalMem = ToMegabytes(sys.TotalPhysicalMemory);
        if (totalMem < TotalMemory)
            return ValidationResult.Invalid;

        return base.Validate(context, type, instance);
    }

    /// <summary>
    /// Converts bytes to megabytes.
    /// </summary>
    /// <param name="bytes">The number of bytes to convert.</param>
    /// <returns>The equivalent value in megabytes.</returns>
    private static long ToMegabytes(long bytes)
    {
        return bytes / 1024 / 1024;
    }

    /// <summary>
    /// Reads the memory restriction data from the specified state.
    /// </summary>
    /// <param name="state">The state object, which can be either an <see cref="XmlReader"/> or a <see cref="BinaryReader"/>.</param>
    public void Read(object state)
    {
        if (state is XmlReader xmlReader)
        {
            xmlReader.MoveToContent();

            string? totalMemory = xmlReader.GetAttribute("totalMemory");
            if (totalMemory != null)
                TotalMemory = XmlConvert.ToInt64(totalMemory);

            bool isEmptyElement = xmlReader.IsEmptyElement;
            xmlReader.ReadStartElement();
            if (!isEmptyElement)
                xmlReader.ReadEndElement();
        }
        else if (state is BinaryReader binaryReader)
        {
            TotalMemory = binaryReader.ReadInt32();
        }
    }

    /// <summary>
    /// Writes the memory restriction data to the specified state.
    /// </summary>
    /// <param name="state">The state object, which can be either an <see cref="XmlWriter"/> or a <see cref="BinaryWriter"/>.</param>
    public void Write(object state)
    {
        if (state is XmlWriter)
        {
            XmlWriter writer = (XmlWriter)state;
            if (TotalMemory != 0)
                writer.WriteAttributeString("totalMemory", XmlConvert.ToString(TotalMemory));
        }
        else if (state is BinaryWriter)
        {
            BinaryWriter writer = (BinaryWriter)state;
            writer.Write(TotalMemory);
        }
    }
}

Full sample project is available on GitHub:

git clone https://github.com/babelfornet/custom_license_restrictions.git

Using Custom Restrictions in License Creation

Once you've defined your custom restriction class, you can use it when generating licenses:

// Create a digital signer
RSASignature signer = RSASignature.CreateFromKeyFile("Keys.snk");

// Requires a minimum of 4GB RAM to validate
int totalMemory = 4096;

var license = new XmlLicense()
              .WithUniqueId()
              .ForProduct("Product", "1.0.0.0")
              .LicensedTo("ACME", "[e-mail]")
              .WithRestrictions(new MemoryRestriction(totalMemory))
              .SignWith(signer);
              
license.Save("Product.licenses");

Use Cases for Custom Restrictions

Custom restrictions can address a wide range of specialized licensing requirements:

• Hardware Requirements: Ensure software only runs on machines meeting minimum specifications.

• Network Configuration: Validate specific network configurations or connectivity requirements.

• Time-Zone Restrictions: Limit software use to specific geographic regions based on time zones.

• Application Co-existence: Verify that required companion applications are installed.

• Database Engine Validation: Ensure compatible database systems are present.

• Cloud Environment Detection: Apply special rules for cloud-hosted deployments.

• Custom Business Rules: Implement industry-specific or organization-specific licensing rules.

Custom Restrictions and License Templates

Custom restrictions can be seamlessly integrated into the Babel Licensing template system, allowing you to save and reuse license configurations that include your custom validation logic. When saved as part of a license template in the Babel Licensing Service, these custom restrictions become reusable components that can be applied consistently across multiple licenses.

Storing Custom Restrictions in License Templates

Once you've implemented a custom restriction, you can incorporate it into a license template through the Babel Licensing Service:

1. Create your license with the custom restriction as shown in the previous example.

2. Save this license as a template in the Babel Licensing Database.

3. The template, including the custom restriction, becomes available for generating new licenses.

Benefits of Template-Based Custom Restrictions

Storing custom restrictions in license templates offers several advantages:

1. Consistency: Ensures that all licenses generated from the template apply the same custom validation rules, maintaining consistency across your licensing strategy.

2. Centralized Management: Manage your custom restrictions from a single location within the Babel Licensing Service, making it easier to update or modify licensing rules.

3. Simplified License Generation: Generate new licenses with complex custom restrictions without having to reimplement the validation logic each time.

4. Versioning and Tracking: Keep track of different versions of your custom restrictions as your licensing requirements evolve.

5. Integration with Licensing Workflows: Incorporate custom restrictions into your existing licensing processes, such as license activation, floating licenses, or file-based licenses.

Example Workflow

Here's a typical workflow for utilizing custom restrictions within the Babel Licensing Service template system:

1. Development: Create and test your custom restriction class in your development environment.

2. Template Creation: Develop a license with your custom restriction and save it as a template:

   var licenseKey = new XmlLicense()
                    .WithUniqueId()
                    .ForProduct("Product", "1.0.0.0")
                    .WithRestrictions(new MemoryRestriction(4096))
                    .SignWith(signer)
                    .ToReadableString();
                 
   // Store licenseKey in Babel Licensing Service

3. License Generation: Use the template to generate specific licenses for customers.

4. Distribution: Distribute the generated license to the customer using your preferred delivery method (direct download, email, activation code, etc.).

5. Validation: When the customer uses your application, the custom restriction validation logic is executed as part of the license validation process.

Implementing Template-Compatible Custom Restrictions

To ensure your custom restrictions work well within the template system, consider these implementation guidelines:

1. Parameter Flexibility: Design your custom restriction class to support both parameterized initialization (for programmatic creation) and parameter-less initialization (for template-based creation).

2. XML Serialization: Implement the IXmlSerializable interface properly to ensure your custom restriction's configuration can be saved to and loaded from license templates.

3. Backward Compatibility: Maintain backward compatibility when updating custom restrictions to ensure that existing templates and licenses continue to function.

4. Error Handling: Implement robust error handling in both your serialization and validation logic to prevent issues when your custom restriction is used in a template.

Integration with Babel Licensing Service Features

Custom restrictions stored in templates can leverage the full suite of Babel Licensing Service features:

• Activation Licenses: Apply custom restrictions to licenses that require activation, adding your specialized validation to the activation process.

• Floating Licenses: Use custom restrictions with floating licenses to add specialized validation criteria to concurrent license usage.

• File Licenses: Include custom restrictions in file-based licenses for offline validation scenarios.

By incorporating custom restrictions into your license templates within the Babel Licensing Service, you create a powerful, flexible, and maintainable licensing system that can address even the most unique and specialized licensing requirements while maintaining the benefits of centralized license management.

Best Practices for Custom Restrictions

1. Keep Validation Fast: Custom restriction validation code runs during license checking, so keep it efficient.

2. Handle Exceptions: Ensure your validation code handles exceptions gracefully to prevent application crashes.

3. Provide Clear Feedback: When validation fails, return meaningful information about why the validation failed.

4. Secure Sensitive Logic: Any sensitive validation logic in your custom restriction could be subject to reverse engineering; consider obfuscation for critical code.

5. Test Comprehensively: Test your custom restrictions in various environments to ensure consistent behavior.

6. Document Thoroughly: Document your custom restrictions for both internal development and customer-facing materials.

Custom restrictions extend Babel Licensing's capabilities to address unique licensing requirements, providing a flexible and powerful licensing solution tailored to your specific needs. These specialized validation rules enable you to implement precisely the licensing model your application requires, giving you complete control over how your software is licensed and used.

Combining Restrictions

A powerful feature of Babel Licensing is the ability to combine multiple restrictions to create sophisticated licensing models. For example, you might combine:

• Trial + Hardware: A time-limited trial that's bound to a specific machine

• Domain + Usage: A license valid only within a corporate domain and in non-virtual environments

• Beta + Custom: A beta license with custom restrictions for specific testing scenarios

When multiple restrictions are applied, all restrictions must be satisfied for the license to be considered valid. This allows for precise control over how your software is licensed and used.

Best Practices for Using Restrictions

1. Start Simple: Begin with the minimum restrictions necessary and add more as your licensing needs evolve.

2. Consider User Experience: Balance security with usability. Overly restrictive licenses may frustrate legitimate users.

3. Provide Clear Feedback: When a restriction causes a license validation failure, ensure your application provides clear information about why the license is invalid.

4. Test Thoroughly: Test all restriction combinations to ensure they work as expected in various scenarios.

5. Document for End Users: Clearly document the restrictions applied to each license type so customers understand the limitations.

6. Implement Graceful Degradation: Where possible, consider allowing limited functionality rather than complete application failure when certain restrictions are not met.

Effective utilization of license restrictions in your templates creates a flexible licensing system that protects your intellectual property while providing appropriate access to customers based on their licensing level. These restrictions serve as the foundation for implementing sophisticated licensing models that balance security with usability, ensuring that your software is used according to your licensing terms while delivering a seamless experience for legitimate users.