Skip to content
← Tous les articles
· Delta1 Labs LicensingKeyright

Exécutez pour toujours les versions que vous avez payées

Une licence perpétuelle avec fenêtre de maintenance permet à un client d'exécuter à jamais toutes les versions publiées pendant que ses mises à jour étaient actives, mais pas les versions que vous publiez après son expiration. Voici comment modéliser cela dans une seule licence Keyright signée : une revendication maintenance-through, la date de publication de la build intégrée à votre assembly, et l'unique comparaison qui ne doit jamais échouer en fermé.

La plupart des modèles de licence basés sur le temps répondent à une question : la licence est-elle encore valide à l”instant même ? Un abonnement expire, l”application consulte l”horloge, et passé la date, elle échoue en fermé. C”est la bonne forme pour une location. C”est la mauvaise forme pour le plus ancien modèle commercial du logiciel de bureau : achetez-le une fois, possédez-le à jamais, payez séparément pour continuer à recevoir des mises à jour.

Dans ce modèle, la licence n”expire jamais pour exécuter le produit. Ce qui expire, c”est le droit du client à de nouvelles builds. Un client qui a acheté la version 2.0 avec un an de maintenance peut exécuter la 2.0 — et toutes les versions que vous avez publiées durant cette année — pour le reste des temps. Quand la version de l”année suivante arrive et que sa maintenance a expiré, cette build n”est simplement pas encore la sienne. On appelle parfois cela une licence perpétuelle de repli (perpetual-fallback), et bien faire les choses dépend d”une comparaison qui, contrairement à toute autre vérification d”expiration que vous avez écrite, ne doit pas échouer en fermé.

Le contrat : perpétuelle pour exécuter, une fenêtre pour mettre à jour

Séparez les deux horloges dans votre tête, car toute la conception découle de leur maintien à part :

  • La durée de vie de la licence est éternelle. Le Kind est Perpetual, l”ExpiryUtc est null, et Validate() renvoie IsValid = true pour le reste de la vie de la licence. Rien ici ne décompte.
  • La fenêtre de maintenance est une date : appelez-la maintenance_through. Elle dit : ce client a droit à toute build que vous avez publiée ce jour-là ou avant. Ce n”est pas une expiration. Elle ne rend jamais la licence invalide. Elle répond seulement à la question de savoir si une build particulière est couverte.

Comme une licence perpétuelle n”a pas d”ExpiryUtc, vous ne pouvez pas glisser la date de maintenance dans le champ d”expiration sans transformer toute la licence en un abonnement qui échoue en fermé — ce qui verrouillerait le client hors d”un logiciel qu”il possède dès l”expiration de la maintenance. La fenêtre de maintenance est sa propre revendication, délibérément tenue hors de la voie d”expiration.

{
  "sub": "acct_8f21c",
  "tier": "pro",
  "kind": "perpetual",
  "iat": "2026-11-12T00:00:00Z",
  "exp": null,
  "claims": {
    "maintenance_through": "2027-11-12"
  }
}

Un seul objet signé. exp est null, donc la licence s”exécute à jamais. maintenance_through est une date que le client peut voir sur son reçu, et elle gouverne exactement une chose : quelles builds il peut exécuter.

Pourquoi une date, pas un numéro de version

L”instinct naïf est d”estamper une version maximale dans la licence : « sous licence jusqu”à 2.x ». Résistez-y. Les versions sémantiques sont un graphe, pas une ligne. Vous pourriez publier 2.4.1 comme correctif de sécurité de l”ancienne branche après que 3.0 soit déjà sortie sur la nouvelle. Désormais « cette version est-elle dans la plage sous licence ? » est une question de topologie de branches, et chaque réponse que vous donnez est discutable.

Une date de publication est un axe monotone unique. Une build a été publiée un jour ; la maintenance a couru jusqu”à un jour ; l”un est antérieur ou postérieur à l”autre, sans égalités à raisonner. Donc la licence porte une date, et chaque build porte la date à laquelle elle a été publiée. Vous comparez deux nombres fixes.

Une licence perpétuelle, une fenêtre de maintenancefenêtre de maintenance : couvert à jamaismaintenance_through2027-11-121.02026-111.52027-052.02027-102.12027-123.02028-04publié après la fenêtre : renouvellement requis2.0 = repli perpétuel : la dernière build que cettelicence peut exécuter, et elle peut le faire à jamais

Intégrez la date de publication dans la build

La build doit savoir quand elle a été publiée. Un attribut d”assembly à la compilation est l”endroit naturel, mais réglez-le depuis la publication — le moment où votre pipeline publie l”artefact — et non depuis l”horloge qu”avait la machine locale lors d”une build de dev. Passez-le depuis la CI comme une propriété MSBuild :

<!-- ReleaseDate est fourni par le pipeline de publication :
     dotnet build -p:ReleaseDate=2027-10-14 -->
<PropertyGroup>
  <ReleaseDate Condition="'$(ReleaseDate)' == ''">1900-01-01</ReleaseDate>
</PropertyGroup>
<ItemGroup>
  <AssemblyMetadata Include="ReleaseDate" Value="$(ReleaseDate)" />
</ItemGroup>

La valeur par défaut 1900-01-01 est délibérée : une build qui n”a pas été produite par le pipeline de publication (le portable de quelqu”un) se lit comme impossiblement ancienne et est couverte par n”importe quelle licence réelle, donc les builds locales ne déclenchent jamais la vérification. Relisez-la une fois au démarrage :

static class BuildInfo
{
    public static DateOnly ReleaseDate { get; } =
        typeof(BuildInfo).Assembly
            .GetCustomAttributes<AssemblyMetadataAttribute>()
            .Where(a => a.Key == "ReleaseDate")
            .Select(a => DateOnly.ParseExact(a.Value!, "yyyy-MM-dd"))
            .DefaultIfEmpty(new DateOnly(1900, 1, 1))
            .First();
}

L”unique comparaison qui ne doit pas échouer en fermé

Toute autre vérification d”expiration que vous avez écrite lit « maintenant » et refuse le service passé une date. Celle-ci ne touche pas du tout à l”horloge. Les deux opérandes sont fixes : la date de publication de la build est une constante intégrée dans l”assembly, et la date de maintenance est une revendication signée que vous avez déjà vérifiée hors ligne. Vous posez une seule question : cette build a-t-elle été publiée pendant la fenêtre que le client a payée ?

public enum MaintenanceStatus { Covered, OutsideWindow }

public MaintenanceStatus CheckMaintenance(LicenseInfo info)
{
    // Validate() a déjà confirmé la signature et qu'il s'agit d'une licence
    // perpétuelle, valide et payante. La seule question restante : quelles BUILDS couvre-t-elle ?
    DateOnly? through = info.Claims.GetDate("maintenance_through");

    // Pas de revendication de maintenance = mises à jour à vie (p. ex. un tier
    // qui ne limite jamais les versions). L'absence N'EST PAS une expiration : échouez en OUVERT.
    if (through is not { } cutoff)
        return MaintenanceStatus.Covered;

    return BuildInfo.ReleaseDate <= cutoff
        ? MaintenanceStatus.Covered         // publiée à/avant la limite -> sous licence, à jamais
        : MaintenanceStatus.OutsideWindow;  // cette build est plus récente que la couverture du client
}

Deux décisions portent tout le modèle. D”abord, une revendication absente échoue en ouvert : une licence perpétuelle sans fenêtre de maintenance doit tout exécuter, car l”absence de fenêtre n”est pas une fenêtre expirée. Ensuite, OutsideWindow n”est pas un état invalide : la licence reste parfaitement valide et payante ; le client a simplement installé une build plus récente que celle qu”il a achetée.

Remarquez ce qui n”est pas dans cette fonction : DateTimeOffset.UtcNow. Comme aucun opérande ne dépend de l”heure actuelle, cette vérification est immunisée contre le recul de l”horloge par construction. Un client qui recule son horloge de cinq ans ne change rien : la build a tout de même été publiée après l”épuisement de sa maintenance. C”est un agréable contraste avec l”expiration d”un abonnement, où « maintenant » est exactement la valeur qu”un attaquant veut déplacer.

Le câblage au démarrage

Gardez les deux préoccupations dans l”ordre qu”exige le modèle : d”abord ce client a-t-il une licence tout court ?, puis cette build est-elle couverte ?

var info = client.Validate();   // hors ligne, contre la clé publique intégrée

if (!info.IsValid || !info.IsPaid)
{
    // Pas un client payant : la voie ordinaire d'échec en fermé.
    RunAsCommunityEdition();
    return;
}

switch (licensing.CheckMaintenance(info))
{
    case MaintenanceStatus.Covered:
        RunLicensed(info);
        break;

    case MaintenanceStatus.OutsideWindow:
        // Valide, payante, perpétuelle : il POSSÈDE le produit. Il a juste installé
        // une build publiée après l'expiration de ses mises à jour.
        ShowMaintenanceLapsedNotice(info.Claims.GetDate("maintenance_through"));
        RunLicensed(info);   // laissez-le continuer à travailler ; voir ci-dessous
        break;
}

La branche OutsideWindow est là où les produits se trompent. Échouer en fermé vers Community Edition là — retirer des fonctions payantes parce que le client a installé une mise à jour — transforme une amélioration en rétrogradation et se lit, à juste titre, comme le produit prenant en otage le logiciel du client lui-même. Les options honnêtes sont plus étroites :

  • Recommandé : laissez l”application s”exécuter et affichez un avis calme et fermable : « La version 2.1 a été publiée après la fin de votre maintenance le 12 novembre 2027. Renouvelez pour obtenir les dernières mises à jour, ou continuez sur la version 2.0, que votre licence couvre de façon permanente. » Le client conserve tout ce qu”il a payé.
  • Plus strict, toujours juste : refusez de lancer cette build et dirigez-le vers la dernière version couverte (2.0), qu”il peut télécharger et exécuter à jamais. Vous déclinez d”exécuter une build plus récente, vous ne révoquez pas la licence.

Ce que vous ne faites jamais, c”est rétrograder un client perpétuel payant vers la Community Edition gratuite à cause d”une date qui gouverne les mises à jour, non la propriété.

Le flux administrateur : renouveler la maintenance

Renouveler la maintenance n”est ni un nouveau produit ni une nouvelle clé de signature : c”est la même licence perpétuelle avec la fenêtre avancée. Dans le service d”émission, vous réémettez pour le même compte avec un maintenance_through ultérieur ; sub, tier et kind sont inchangés :

keyright license reissue \
  --account acct_8f21c \
  --kind perpetual \
  --maintenance-through 2028-11-12

Le client reçoit la licence réémise, la réactive, et chaque build que vous publiez jusqu”à la nouvelle date devient couverte. Rien ne change pour les anciennes installations : une machine qui exécute encore la 2.0 était déjà couverte et le reste. Comme la date de maintenance voyage à l”intérieur du contenu signé, le seul moyen d”étendre la couverture est de se voir émettre une nouvelle licence ; modifier la date à la main dans le fichier casse la signature et toute la licence échoue à la vérification, ce qui est le comportement d”échec en fermé que vous voulez bien.

Un enseignement pratique

La licence perpétuelle de repli, c”est une revendication et une comparaison, mais la comparaison tourne à l”envers de toute autre vérification d”expiration que vous possédez. Gardez la date de maintenance hors de la voie d”ExpiryUtc pour que la licence n”expire jamais à l”exécution. Comparez une date de publication intégrée à une date maintenance-through signée, jamais une chaîne de version et jamais l”horloge du système. Échouez en ouvert quand la revendication est absente, et traitez une build hors de la fenêtre comme « plus récente que votre couverture » plutôt que « sans licence ». Fait ainsi, laisser la maintenance expirer fait exactement ce que le contrat a promis au client à l”achat : il conserve l”exécution de chaque version qu”il a payée, aussi longtemps qu”il le souhaite — et le jour où il veut votre build la plus récente, renouveler est un changement de date, pas un nouveau marché.

Essayez Nebula.NET

Renforcez votre code .NET en quelques minutes — commencez avec l'édition gratuite.