Restrizioni della licenza

La sezione Restrizioni di un modello di Babel Licensing ti permette di definire vincoli specifici sul modo in cui le licenze possono essere usate. Queste restrizioni offrono un controllo granulare sul comportamento della licenza e ti permettono di implementare vari modelli di licensing e di imporre condizioni di utilizzo. Babel Licensing offre diversi tipi di restrizione predefiniti e la possibilità di creare restrizioni personalizzate.

Panoramica delle restrizioni della licenza

Le restrizioni della licenza sono condizioni vincolanti che determinano come, quando e dove il tuo software può essere usato con una determinata licenza. Ogni tipo di restrizione riguarda un aspetto specifico del controllo della licenza, dall’utilizzo limitato nel tempo al vincolo all’hardware. In un unico modello di licenza puoi combinare più restrizioni per creare modelli di licensing articolati, adatti alle tue esigenze specifiche.

Quando una licenza ha più restrizioni, TUTTE le restrizioni devono essere convalidate singolarmente perché la licenza sia considerata valida. Se anche una sola restrizione non supera la convalida, l’intera convalida della licenza fallisce. In questo modo puoi creare condizioni di licenza molto specifiche, in cui tutti i vincoli definiti devono essere soddisfatti contemporaneamente.

Restrizione beta

La restrizione beta è pensata per il software in pre-rilascio: contrassegna le licenze con informazioni che indicano che il software è in fase beta.

Proprietà principali:

Tipo di build: specifica il tipo di build (per esempio “Alpha”, “Beta”, “RC”) per indicare la fase di sviluppo del software.
Modifiche recenti: un campo di testo in cui documentare le modifiche o le funzionalità specifiche di questo rilascio beta.

Casi d’uso:

Distribuire versioni in accesso anticipato a tester o a clienti selezionati
Programmi beta a tempo limitato prima del rilascio completo del prodotto
Limitare la responsabilità identificando chiaramente il software come pre-rilascio

Esempio di implementazione:


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

Restrizione hardware

La restrizione hardware vincola una licenza a un hardware specifico e ne impedisce l’uso non autorizzato su altri computer. Lo fa tramite una chiave hardware generata dalle caratteristiche univoche del computer di destinazione.

Proprietà principali:

Chiave hardware: un identificatore univoco generato dai componenti hardware del computer (nel modello può essere vuoto e venire compilato durante l’attivazione della licenza).
Dati: dati aggiuntivi utilizzabili per memorizzare informazioni specifiche dell’hardware.

Casi d’uso:

Licenze perpetue per un singolo computer
Impedire la condivisione della licenza tra più dispositivi
Ambienti ad alta sicurezza, in cui il software deve essere vincolato a hardware autorizzato

Nota: quando usi licenze con attivazione, la restrizione hardware viene applicata automaticamente durante il processo di attivazione, perché la licenza viene vincolata al computer specifico tramite il suo ID hardware. Non è quindi necessario aggiungere esplicitamente una restrizione hardware ai modelli di licenza che usano la modalità di licenza con attivazione. È il processo di attivazione stesso a gestire il vincolo all’hardware.

Restrizione di prova

La restrizione di prova limita l’utilizzo del software in base al tempo o a parametri di esecuzione, ed è quindi ideale per realizzare versioni di prova gratuite del tuo software.

Proprietà principali:

Giorni di validità: numero di giorni per cui la prova è valida dopo il primo utilizzo.
Istanze in esecuzione: numero massimo di istanze simultanee consentite.
Numero di esecuzioni: numero massimo complessivo di esecuzioni dell’applicazione consentite.
Tempo di esecuzione: durata massima per cui l’applicazione può restare in esecuzione in ogni sessione.
Termini: termini e condizioni speciali che si applicano alla licenza di prova.

Casi d’uso:

Versioni demo a tempo limitato
Versioni di prova con funzionalità limitate
Versioni demo limitate per numero di utilizzi
Implementazione del modello freemium

Esempio di implementazione:


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

Restrizione di dominio

La restrizione di dominio limita l’utilizzo della licenza a un dominio di rete specifico, così il software può essere usato solo entro i confini autorizzati dell’organizzazione.

Proprietà principali:

Dominio: il nome del dominio di rete in cui la licenza è valida (per esempio “example.com”).
Ruolo: identificatore facoltativo del ruolo all’interno del dominio (per esempio “developer”, “admin”).

Casi d’uso:

Licenze aziendali per organizzazioni specifiche
Limitare l’uso del software alle reti aziendali autorizzate
Termini di licenza diversi per unità organizzative diverse

Restrizione di utilizzo

La restrizione di utilizzo definisce l’ambiente in cui l’applicazione può essere eseguita, e ti dà il controllo sugli scenari di distribuzione e sui contesti di esecuzione.

Proprietà principali:

Utilizzo: identifica l’ambiente o il contesto di utilizzo consentito.
Può essere eseguita in un ambiente virtuale: quando è true, permette al software di essere eseguito in ambienti virtualizzati.
Elenco processi: un elenco di processi che devono, o non devono, essere in esecuzione perché la licenza sia valida.

Casi d’uso:

Impedire l’esecuzione in macchine virtuali per le applicazioni sensibili dal punto di vista della sicurezza
Limitare il software ad ambienti specifici (sviluppo, preproduzione, produzione)
Richiedere o vietare la presenza di specifici processi complementari

Restrizioni personalizzate

Oltre alle restrizioni predefinite, Babel Licensing ti permette di creare restrizioni personalizzate per i requisiti di licenza propri della tua applicazione. Le restrizioni personalizzate sono estensioni potenti, con cui implementare una logica di convalida specializzata, adatta alle tue esigenze aziendali e tecniche.

Implementare restrizioni personalizzate

Per creare una restrizione personalizzata devi implementare una classe che eredita da Restriction e implementa l’interfaccia ILicenseSerializable. Hai così il controllo completo sia sulla logica di convalida sia sul modo in cui la restrizione viene serializzata nel file di licenza.

Componenti principali di una restrizione personalizzata:

Proprietà Name: un identificatore univoco del tuo tipo di restrizione.
Proprietà personalizzate: proprietà specifiche della funzione svolta dalla restrizione.
Logica di convalida: codice personalizzato che determina se la licenza è valida in base ai tuoi criteri.
Metodi di serializzazione: metodi per leggere e scrivere i dati della restrizione in formato XML o binario.

Esempio: restrizione sui requisiti di memoria

Ecco un esempio di restrizione personalizzata che verifica se un computer soddisfa i requisiti minimi di memoria.


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

Il progetto di esempio completo è disponibile su GitHub:


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

Usare le restrizioni personalizzate nella creazione delle licenze

Una volta definita la classe della restrizione personalizzata, puoi usarla quando generi le licenze:


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

Casi d’uso delle restrizioni personalizzate

Le restrizioni personalizzate possono rispondere a un’ampia gamma di requisiti di licenza specializzati:

Requisiti hardware: assicurati che il software venga eseguito solo su computer che soddisfano le specifiche minime.
Configurazione di rete: convalida configurazioni di rete o requisiti di connettività specifici.
Restrizioni per fuso orario: limita l’uso del software a regioni geografiche specifiche in base ai fusi orari.
Coesistenza di applicazioni: verifica che le applicazioni complementari richieste siano installate.
Convalida del motore di database: assicurati che siano presenti sistemi di database compatibili.
Rilevamento dell’ambiente cloud: applica regole speciali alle distribuzioni ospitate nel cloud.
Regole aziendali personalizzate: implementa regole di licenza specifiche del settore o dell’organizzazione.

Restrizioni personalizzate e modelli di licenza

Le restrizioni personalizzate si integrano senza difficoltà nel sistema dei modelli di Babel Licensing, e ti permettono di salvare e riutilizzare configurazioni di licenza che includono la tua logica di convalida personalizzata. Quando vengono salvate come parte di un modello di licenza nel Babel Licensing Service, queste restrizioni personalizzate diventano componenti riutilizzabili, da applicare in modo uniforme a più licenze.

Archiviare le restrizioni personalizzate nei modelli di licenza

Una volta implementata una restrizione personalizzata, puoi inserirla in un modello di licenza tramite il Babel Licensing Service:

Crea la licenza con la restrizione personalizzata, come mostrato nell’esempio precedente.
Salva questa licenza come modello nel database di Babel Licensing.
Il modello, restrizione personalizzata inclusa, diventa disponibile per generare nuove licenze.

Vantaggi delle restrizioni personalizzate basate sui modelli

Archiviare le restrizioni personalizzate nei modelli di licenza offre diversi vantaggi:

Coerenza: tutte le licenze generate dal modello applicano le stesse regole di convalida personalizzate, e la tua strategia di licensing resta coerente.
Gestione centralizzata: gestisci le restrizioni personalizzate da un unico punto all’interno del Babel Licensing Service, così è più facile aggiornare o modificare le regole di licenza.
Generazione delle licenze semplificata: genera nuove licenze con restrizioni personalizzate complesse senza dover reimplementare ogni volta la logica di convalida.
Versioni e tracciamento: tieni traccia delle diverse versioni delle tue restrizioni personalizzate man mano che i requisiti di licenza evolvono.
Integrazione con i flussi di lavoro delle licenze: inserisci le restrizioni personalizzate nei tuoi processi di licenza esistenti, come l’attivazione della licenza, le licenze flottanti o le licenze a file.

Flusso di lavoro di esempio

Ecco un flusso di lavoro tipico per usare le restrizioni personalizzate nel sistema dei modelli del Babel Licensing Service:

Sviluppo: crea e testa la classe della restrizione personalizzata nel tuo ambiente di sviluppo.

Creazione del modello: prepara una licenza con la restrizione personalizzata e salvala come modello:


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

Generazione delle licenze: usa il modello per generare licenze specifiche per i clienti.
Distribuzione: distribuisci al cliente la licenza generata con il metodo di consegna che preferisci (download diretto, email, codice di attivazione e così via).
Convalida: quando il cliente usa la tua applicazione, la logica di convalida della restrizione personalizzata viene eseguita come parte della convalida della licenza.

Implementare restrizioni personalizzate compatibili con i modelli

Perché le tue restrizioni personalizzate funzionino bene nel sistema dei modelli, tieni presenti queste indicazioni di implementazione:

Flessibilità dei parametri: progetta la classe della restrizione personalizzata in modo che supporti sia l’inizializzazione con parametri (per la creazione da codice) sia quella senza parametri (per la creazione da modello).
Serializzazione XML: implementa correttamente l’interfaccia IXmlSerializable, così la configurazione della restrizione personalizzata può essere salvata nei modelli di licenza e caricata da essi.
Compatibilità con le versioni precedenti: quando aggiorni le restrizioni personalizzate mantieni la compatibilità con le versioni precedenti, perché i modelli e le licenze esistenti continuino a funzionare.
Gestione degli errori: implementa una gestione degli errori robusta sia nella logica di serializzazione sia in quella di convalida, per evitare problemi quando la restrizione personalizzata è usata in un modello.

Integrazione con le funzionalità del Babel Licensing Service

Le restrizioni personalizzate archiviate nei modelli possono sfruttare tutte le funzionalità del Babel Licensing Service:

Licenze con attivazione: applica le restrizioni personalizzate alle licenze che richiedono l’attivazione, aggiungendo la tua convalida specializzata al processo di attivazione.
Licenze flottanti: usa le restrizioni personalizzate con le licenze flottanti per aggiungere criteri di convalida specializzati all’utilizzo simultaneo delle licenze.
Licenze a file: includi le restrizioni personalizzate nelle licenze a file per gli scenari di convalida offline.

Inserendo le restrizioni personalizzate nei tuoi modelli di licenza all’interno del Babel Licensing Service crei un sistema di licenze potente, flessibile e facile da mantenere, capace di rispondere anche ai requisiti di licenza più particolari e specializzati conservando i vantaggi della gestione centralizzata delle licenze.

Procedure consigliate per le restrizioni personalizzate

Mantieni veloce la convalida: il codice di convalida di una restrizione personalizzata viene eseguito durante il controllo della licenza, quindi fai in modo che sia efficiente.
Gestisci le eccezioni: assicurati che il codice di convalida gestisca le eccezioni in modo controllato, per evitare arresti anomali dell’applicazione.
Fornisci indicazioni chiare: quando la convalida fallisce, restituisci informazioni utili sul motivo del fallimento.
Proteggi la logica sensibile: qualsiasi logica di convalida sensibile nella tua restrizione personalizzata potrebbe essere oggetto di reverse engineering; valuta l’offuscamento per il codice critico.
Esegui test completi: testa le restrizioni personalizzate in ambienti diversi per garantire un comportamento uniforme.
Documenta in modo accurato: documenta le restrizioni personalizzate sia per lo sviluppo interno sia per i materiali destinati ai clienti.

Le restrizioni personalizzate estendono le capacità di Babel Licensing per rispondere a requisiti di licenza particolari, e offrono una soluzione per le licenze flessibile e potente, adatta alle tue esigenze specifiche. Con queste regole di convalida specializzate puoi implementare esattamente il modello di licensing richiesto dalla tua applicazione, con il controllo completo su come il tuo software viene concesso in licenza e usato.

Combinare le restrizioni

Un punto di forza di Babel Licensing è la possibilità di combinare più restrizioni per creare modelli di licensing articolati. Per esempio, potresti combinare:

Prova + Hardware: una prova a tempo limitato vincolata a un computer specifico
Dominio + Utilizzo: una licenza valida solo all’interno di un dominio aziendale e in ambienti non virtuali
Beta + Personalizzata: una licenza beta con restrizioni personalizzate per scenari di test specifici

Quando sono applicate più restrizioni, devono essere tutte soddisfatte perché la licenza sia considerata valida. In questo modo controlli con precisione come il tuo software viene concesso in licenza e usato.

Procedure consigliate per l’uso delle restrizioni

Parti dal semplice: comincia con le restrizioni minime necessarie e aggiungine altre man mano che le tue esigenze di licenza evolvono.
Considera l’esperienza dell’utente: bilancia sicurezza e usabilità. Licenze troppo restrittive possono frustrare gli utenti legittimi.
Fornisci indicazioni chiare: quando una restrizione fa fallire la convalida della licenza, assicurati che la tua applicazione spieghi chiaramente perché la licenza non è valida.
Esegui test approfonditi: testa tutte le combinazioni di restrizioni per verificare che funzionino come previsto nei vari scenari.
Documenta per gli utenti finali: documenta chiaramente le restrizioni applicate a ogni tipo di licenza, così i clienti ne comprendono i limiti.
Prevedi una degradazione controllata: dove possibile, valuta di consentire una funzionalità limitata invece del blocco completo dell’applicazione quando alcune restrizioni non sono soddisfatte.

Un uso efficace delle restrizioni della licenza nei tuoi modelli crea un sistema di licenze flessibile, che protegge la tua proprietà intellettuale e offre ai clienti un accesso adeguato al loro livello di licenza. Queste restrizioni sono la base per implementare modelli di licensing articolati che bilanciano sicurezza e usabilità: il tuo software viene usato secondo i tuoi termini di licenza e gli utenti legittimi non incontrano ostacoli.