Restrictions de licence

La section Restrictions d’un modèle Babel Licensing permet de définir des contraintes précises sur l’utilisation des licences. Ces restrictions donnent un contrôle fin sur le comportement des licences : vous pouvez ainsi mettre en œuvre différentes formules de licence et imposer des conditions d’utilisation. Babel Licensing propose plusieurs types de restrictions intégrés, ainsi que la possibilité de créer des restrictions personnalisées.

Vue d’ensemble des restrictions de licence

Les restrictions de licence sont des conditions contraignantes qui déterminent comment, quand et où votre logiciel peut être utilisé avec une licence donnée. Chaque type de restriction porte sur un aspect précis du contrôle des licences, de l’utilisation limitée dans le temps à la liaison au matériel. Plusieurs restrictions peuvent être combinées dans un même modèle de licence pour créer des formules de licence élaborées, adaptées à vos exigences.

Restriction bêta

La restriction bêta est destinée aux logiciels en préversion : elle marque les licences d’une information indiquant que le logiciel est en version bêta.

Propriétés principales :

• Type de build : indique le type de build (par exemple « Alpha », « Beta », « RC ») pour signaler le stade de développement du logiciel.
• Modifications récentes : un champ de texte où vous pouvez décrire les modifications ou les fonctionnalités propres à cette version bêta.

Cas d’utilisation :

• Distribution de versions en accès anticipé à des testeurs ou à des clients choisis
• Programmes bêta limités dans le temps avant la sortie complète du produit
• Limitation de la responsabilité en identifiant clairement le logiciel comme une préversion

Exemple d’implémentation :

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

Restriction matérielle

La restriction matérielle lie une licence à un matériel précis, ce qui empêche toute utilisation non autorisée sur d’autres machines. Elle repose sur une clé matérielle générée à partir des caractéristiques uniques de l’ordinateur cible.

Propriétés principales

• Clé matérielle : un identifiant unique généré à partir des composants matériels de la machine (il peut rester vide dans le modèle et être renseigné lors de l’activation de la licence).
• Données : des données supplémentaires pouvant servir à stocker des informations propres au matériel.

Cas d’utilisation :

• Licences perpétuelles pour une seule machine
• Prévention du partage d’une licence entre plusieurs appareils
• Environnements à haute sécurité où le logiciel doit être lié à un matériel autorisé

Restriction d’essai

La restriction d’essai limite l’utilisation du logiciel selon la durée ou des paramètres d’exécution, ce qui en fait le moyen idéal de proposer des versions d’essai gratuites de votre logiciel.

Propriétés principales :

• Jours avant expiration : nombre de jours pendant lesquels l’essai est valide après la première utilisation.
• Instances en cours : nombre maximal d’instances simultanées autorisées.
• Nombre d’exécutions : nombre total maximal d’exécutions de l’application autorisées.
• Durée d’exécution : durée maximale pendant laquelle l’application peut s’exécuter par session.
• Conditions : conditions particulières qui s’appliquent à la licence d’essai.

Cas d’utilisation :

• Versions d’essai limitées dans le temps
• Versions d’essai aux fonctionnalités limitées
• Versions de démonstration limitées en nombre d’utilisations
• Mise en œuvre d’une formule freemium

Exemple d’implémentation :

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
    }
}

Restriction de domaine

La restriction de domaine limite l’utilisation de la licence à un domaine réseau précis, de sorte que le logiciel ne peut être utilisé qu’à l’intérieur du périmètre autorisé de l’organisation.

Propriétés principales :

• Domaine : le nom du domaine réseau dans lequel la licence est valide (par exemple « example.com »).
• Rôle : identifiant de rôle facultatif au sein du domaine (par exemple « developer », « admin »).

Cas d’utilisation :

• Licences d’entreprise pour des organisations précises
• Limitation de l’utilisation du logiciel aux réseaux d’entreprise autorisés
• Conditions de licence différentes selon les unités de l’organisation

Restriction d’utilisation

La restriction d’utilisation définit l’environnement dans lequel l’application est autorisée à s’exécuter, ce qui permet de contrôler les scénarios de déploiement et les contextes d’exécution.

Propriétés principales :

• Utilisation : identifie l’environnement ou le contexte d’utilisation autorisé.
• Peut fonctionner dans un environnement virtuel : avec la valeur true, autorise le logiciel à s’exécuter dans des environnements virtualisés.
• Liste des processus : une liste de processus qui doivent, ou ne doivent pas, être en cours d’exécution pour que la licence soit valide.

Cas d’utilisation :

• Blocage de l’exécution dans des machines virtuelles pour les applications sensibles sur le plan de la sécurité
• Limitation du logiciel à des environnements précis (développement, préproduction, production)
• Obligation ou interdiction de la présence de certains processus associés

Restrictions personnalisées

Outre les restrictions intégrées, Babel Licensing permet de créer des restrictions personnalisées pour répondre aux exigences de licence propres à votre application. Les restrictions personnalisées sont des extensions qui permettent de mettre en œuvre une logique de validation spécialisée, adaptée à vos besoins métier et techniques.

Implémenter des restrictions personnalisées

Pour créer une restriction personnalisée, vous devez implémenter une classe qui hérite de Restriction et implémente l’interface ILicenseSerializable. Vous contrôlez ainsi entièrement la logique de validation et la façon dont la restriction est sérialisée dans le fichier de licence.

Principaux éléments d’une restriction personnalisée :

1. Propriété Name : un identifiant unique pour votre type de restriction.
2. Propriétés personnalisées : les propriétés propres au fonctionnement de votre restriction.
3. Logique de validation : le code personnalisé qui détermine si la licence est valide selon vos critères.
4. Méthodes de sérialisation : les méthodes qui lisent et écrivent les données de votre restriction au format XML ou binaire.

Exemple : restriction sur la mémoire requise

Voici un exemple de restriction personnalisée qui vérifie qu’une machine dispose de la mémoire minimale requise.

/// <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);
        }
    }
}

Le projet d’exemple complet est disponible sur GitHub :

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

Utiliser des restrictions personnalisées lors de la création de licences

Une fois la classe de votre restriction personnalisée définie, vous pouvez l’utiliser lorsque vous générez des licences :

// 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", "devs@acme.com")
              .WithRestrictions(new MemoryRestriction(totalMemory))
              .SignWith(signer);
              
license.Save("Product.licenses");

Cas d’utilisation des restrictions personnalisées

Les restrictions personnalisées peuvent répondre à un large éventail d’exigences de licence spécialisées :

• Configuration matérielle requise : s’assurer que le logiciel ne s’exécute que sur des machines répondant à des spécifications minimales.
• Configuration réseau : valider des configurations réseau ou des exigences de connectivité précises.
• Restrictions par fuseau horaire : limiter l’utilisation du logiciel à certaines régions géographiques d’après les fuseaux horaires.
• Coexistence d’applications : vérifier que les applications associées requises sont installées.
• Validation du moteur de base de données : s’assurer que des systèmes de base de données compatibles sont présents.
• Détection d’un environnement cloud : appliquer des règles particulières aux déploiements hébergés dans le cloud.
• Règles métier personnalisées : mettre en œuvre des règles de licence propres à un secteur ou à une organisation.

Restrictions personnalisées et modèles de licence

Les restrictions personnalisées s’intègrent au système de modèles de Babel Licensing, ce qui vous permet d’enregistrer et de réutiliser des configurations de licence qui contiennent votre logique de validation personnalisée. Enregistrées dans un modèle de licence du Babel Licensing Service, ces restrictions personnalisées deviennent des composants réutilisables, qui s’appliquent de façon cohérente à plusieurs licences.

Stocker des restrictions personnalisées dans des modèles de licence

Une fois une restriction personnalisée implémentée, vous pouvez l’intégrer à un modèle de licence par l’intermédiaire du Babel Licensing Service :

1. Créez votre licence avec la restriction personnalisée, comme dans l’exemple précédent.
2. Enregistrez cette licence comme modèle dans la base de données Babel Licensing.
3. Le modèle, restriction personnalisée comprise, devient disponible pour générer de nouvelles licences.

Avantages des restrictions personnalisées stockées dans un modèle

Stocker les restrictions personnalisées dans des modèles de licence présente plusieurs avantages :

1. Cohérence : toutes les licences générées à partir du modèle appliquent les mêmes règles de validation personnalisées, ce qui maintient la cohérence de votre stratégie de licence.
2. Gestion centralisée : vous gérez vos restrictions personnalisées depuis un seul endroit, dans le Babel Licensing Service, ce qui facilite la mise à jour ou la modification des règles de licence.
3. Génération de licences simplifiée : vous générez de nouvelles licences dotées de restrictions personnalisées complexes sans réimplémenter la logique de validation à chaque fois.
4. Gestion des versions et suivi : vous gardez la trace des différentes versions de vos restrictions personnalisées à mesure que vos exigences de licence évoluent.
5. Intégration aux flux de travail de licence : vous intégrez les restrictions personnalisées à vos processus de licence existants, tels que l’activation de licence, les licences flottantes ou les licences fichier.

Exemple de flux de travail

Voici un flux de travail type pour utiliser des restrictions personnalisées dans le système de modèles du Babel Licensing Service :

1. Développement : créez et testez la classe de votre restriction personnalisée dans votre environnement de développement.

2. Création du modèle : préparez une licence avec votre restriction personnalisée et enregistrez-la comme modèle :

   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. Génération des licences : utilisez le modèle pour générer les licences de chaque client.

4. Distribution : remettez la licence générée au client par le moyen de votre choix (téléchargement direct, e-mail, code d’activation, etc.).

5. Validation : lorsque le client utilise votre application, la logique de validation de la restriction personnalisée s’exécute dans le cadre de la validation de licence.

Implémenter des restrictions personnalisées compatibles avec les modèles

Pour que vos restrictions personnalisées fonctionnent bien dans le système de modèles, suivez ces recommandations d’implémentation :

1. Souplesse des paramètres : concevez la classe de votre restriction personnalisée pour qu’elle prenne en charge à la fois l’initialisation avec paramètres (pour la création par programmation) et l’initialisation sans paramètre (pour la création à partir d’un modèle).
2. Sérialisation XML : implémentez correctement l’interface IXmlSerializable pour que la configuration de votre restriction personnalisée puisse être enregistrée dans les modèles de licence et chargée à partir de ceux-ci.
3. Rétrocompatibilité : préservez la rétrocompatibilité lorsque vous mettez à jour des restrictions personnalisées, afin que les modèles et les licences existants continuent de fonctionner.
4. Gestion des erreurs : mettez en place une gestion des erreurs robuste dans la logique de sérialisation comme dans la logique de validation, pour éviter les problèmes lorsque votre restriction personnalisée est utilisée dans un modèle.

Intégration aux fonctionnalités du Babel Licensing Service

Les restrictions personnalisées stockées dans des modèles peuvent tirer parti de l’ensemble des fonctionnalités du Babel Licensing Service :

• Licences d’activation : appliquez des restrictions personnalisées aux licences qui exigent une activation, pour ajouter votre validation spécialisée au processus d’activation.
• Licences flottantes : utilisez des restrictions personnalisées avec les licences flottantes pour ajouter des critères de validation spécialisés à l’utilisation simultanée des licences.
• Licences fichier : incluez des restrictions personnalisées dans les licences fichier pour les scénarios de validation hors ligne.

En intégrant des restrictions personnalisées à vos modèles de licence dans le Babel Licensing Service, vous obtenez un système de gestion des licences puissant, souple et facile à maintenir, capable de répondre aux exigences de licence les plus particulières tout en conservant les avantages d’une gestion centralisée des licences.

Bonnes pratiques pour les restrictions personnalisées

1. Garder une validation rapide : le code de validation d’une restriction personnalisée s’exécute pendant le contrôle de la licence ; veillez à ce qu’il reste efficace.
2. Gérer les exceptions : assurez-vous que votre code de validation gère correctement les exceptions pour éviter les plantages de l’application.
3. Fournir un retour clair : lorsque la validation échoue, renvoyez des informations utiles sur la raison de l’échec.
4. Protéger la logique sensible : toute logique de validation sensible de votre restriction personnalisée peut être soumise à la rétro-ingénierie ; envisagez l’obfuscation pour le code critique.
5. Tester de manière exhaustive : testez vos restrictions personnalisées dans différents environnements pour vérifier que leur comportement est constant.
6. Documenter en détail : documentez vos restrictions personnalisées, pour le développement interne comme pour les documents destinés aux clients.

Les restrictions personnalisées étendent les capacités de Babel Licensing pour répondre à des exigences de licence particulières : vous disposez d’une solution de licence souple, adaptée à vos besoins. Ces règles de validation spécialisées vous permettent de mettre en œuvre exactement la formule de licence dont votre application a besoin et vous donnent un contrôle complet sur la façon dont votre logiciel est concédé sous licence et utilisé.

Combiner des restrictions

L’un des atouts de Babel Licensing est la possibilité de combiner plusieurs restrictions pour créer des formules de licence élaborées. Vous pouvez par exemple combiner :

• Essai + Matériel : un essai limité dans le temps et lié à une machine précise
• Domaine + Utilisation : une licence valide uniquement dans un domaine d’entreprise et dans des environnements non virtuels
• Bêta + Personnalisée : une licence bêta avec des restrictions personnalisées pour des scénarios de test précis

Lorsque plusieurs restrictions sont appliquées, toutes doivent être satisfaites pour que la licence soit considérée comme valide. Vous contrôlez ainsi avec précision la façon dont votre logiciel est concédé sous licence et utilisé.

Bonnes pratiques d’utilisation des restrictions

1. Commencer simplement : commencez par le minimum de restrictions nécessaire et ajoutez-en à mesure que vos besoins de licence évoluent.
2. Penser à l’expérience utilisateur : trouvez l’équilibre entre sécurité et facilité d’utilisation. Des licences trop restrictives peuvent frustrer les utilisateurs légitimes.
3. Fournir un retour clair : lorsqu’une restriction fait échouer la validation de licence, veillez à ce que votre application indique clairement pourquoi la licence n’est pas valide.
4. Tester en profondeur : testez toutes les combinaisons de restrictions pour vérifier qu’elles fonctionnent comme prévu dans différents scénarios.
5. Documenter pour les utilisateurs finaux : documentez clairement les restrictions appliquées à chaque type de licence, afin que les clients en comprennent les limites.
6. Prévoir un mode dégradé : lorsque c’est possible, envisagez d’autoriser des fonctionnalités limitées plutôt qu’un arrêt complet de l’application lorsque certaines restrictions ne sont pas satisfaites.

Bien utilisées dans vos modèles, les restrictions de licence donnent un système de gestion des licences souple, qui protège votre propriété intellectuelle tout en donnant aux clients un accès adapté à leur niveau de licence. Ces restrictions sont la base sur laquelle mettre en œuvre des formules de licence élaborées, qui concilient sécurité et facilité d’utilisation : votre logiciel est utilisé conformément à vos conditions de licence, sans gêner les utilisateurs légitimes.