Licenza per C # applicazione del desktop

Question

Come posso aggiungere la mia licenza per C # applicazione desktop? Ho bisogno di trovare un metodo gratuito adatto per impedire agli utenti non autorizzati l'installazione il mio software.

Answer 1

Ci sono un sacco di sistemi di gestione delle licenze là fuori per NET (c'è anche una built-in per le licenze controlli ). Un rapido Google in giro per "gestore di licenza NET" ha gettato la href="https://sourceforge.net/projects/net-lic-mgr/" rel="nofollow noreferrer"> sistema Open License

Mi aspetto che si può facilmente trovare di più.

Answer 2

Probabilmente sono un po 'tardi, ma ho trascorso un po' di tempo a cercare di elaborare un metodo rapido ed efficace per assicurare una piccola applicazione C #, e vorrei condividere i miei risultati.

Sembra che si può costruire il proprio, sistema di licenze abbastanza sicuro utilizzando RSA ragionevolmente facilmente.

Ovviamente, nulla è a prova di proiettile, quando si tratta di proteggere il software (E 'come proteggere la tua casa dai ladri: gli allarmi, cani che abbaiano e recinzioni renderlo più problemi che ne vale la pena, ma non sarà qualcuno fermata determinato a entrare in )

Quindi, il che rende più problemi che ne vale la pena è la frase-chiave di protezione del software: se si sta offrendo un $ 1.000.000 di E.R.P. sistema, si vorrebbe avere davvero una buona protezione che autorizzato tramite un servizio web (e gli utenti che pagano così tanto per un sistema non sarebbe un problema con permettere che l'accesso costante sistema di internet)

Tuttavia, se si carica solo $ 5- $ 30 per una piccola applicazione, gli utenti non stanno andando a mettere in su con l'autorizzazione di mano molto pesante.

Credo che il sistema più semplice per i prodotti è quello di firmare digitalmente una licenza-file che contiene i dettagli del prodotto, l'utente e la sua durata.

Questo significa che qualsiasi modifica del file di licenza rende la firma digitale non valida.

La firma digitale è possibile ottenere dalla classe DSACryptoServiceProvider, utilizzando il metodo SignData.

Una chiave privata è tenuto a firmare i dati, e la parte pubblica di quella chiave può essere utilizzata per convalidare la firma: (quindi la chiave pubblica deve essere accessibile dall'applicazione)

Il DSAXCryptoServiceProvider ha metodi per la creazione e l'utilizzo di tasti:

DSACryptoServiceProvider.ToXMLString (bool includePrivate);

restituisce al pubblico o pubblico e le chiavi private attualmente in fornitore del servizio come una stringa XML.

DSACryptoServiceProvider.FromXMLString (String xmlString)

Questo metodo prevede l'iscrizione di un nuovo DSACryptoServiceProvider con chiavi private o pubbliche ottenute da DSACryptoServiceProvider.ToXMLString () esistente

L'unico difetto nella sicurezza di questo sistema sarebbe la possibilità di un utente di rottura in una fornitura di propria chiave pubblica. Ciò consentirebbe loro di generare i propri file di licenza dalla propria chiave privata.

Questo può essere ottenuto in giro con la firma in aggiunta una risorsa necessaria per l'applicazione (come una DLL che contiene la logica fondamentale per l'applicazione, o anche l'exe stesso) - in tal modo, se la chiave pubblica viene modificata, questa ulteriore (nascosti ) firma sarà più valido.

Altri modi per migliorare questo includono oscurando i termini di licenza (serializzazione di una struttura di dati che contiene i termini della licenza con il binario formattatore a un array di byte, quindi utilizzando Convert.ToBase64String () sarà abbastanza efficace oscurare i termini di licenza, e anche se l'utente è stato in grado di sostituire la chiave pubblica che avrebbero ancora bisogno di lavoro fuori la rappresentazione dei dati)

ho un esempio di sistema che ho scritto, ma è troppo grande per citare tutto, ma questo è il metodo CreateLicense da esso:

    /// <summary>
    /// use a private key to generate a secure license file. the private key must match the public key accessible to
    /// the system validating the license.
    /// </summary>
    /// <param name="start">applicable start date for the license file.</param>
    /// <param name="end">applicable end date for the license file</param>
    /// <param name="productName">applicable product name</param>
    /// <param name="userName">user-name</param>
    /// <param name="privateKey">the private key (in XML form)</param>
    /// <returns>secure, public license, validated with the public part of the key</returns>
    public static License CreateLicense(DateTime start, DateTime end, String productName, String userName, String privateKey)
    {
        // create the licence terms:
        LicenseTerms terms = new LicenseTerms()
        {
            StartDate = start,
            EndDate = end,
            ProductName = productName,
            UserName = userName
        };

        // create the crypto-service provider:
        DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();

        // setup the dsa from the private key:
        dsa.FromXmlString(privateKey);

        // get the byte-array of the licence terms:
        byte[] license = terms.GetLicenseData();

        // get the signature:
        byte[] signature = dsa.SignData(license);

        // now create the license object:
        return new License()
        {
            LicenseTerms = Convert.ToBase64String(license),
            Signature = Convert.ToBase64String(signature)
        };
    }

Verifica Metodo:

    /// <summary>
    /// validate license file and return the license terms.
    /// </summary>
    /// <param name="license"></param>
    /// <param name="publicKey"></param>
    /// <returns></returns>
    internal static LicenseTerms GetValidTerms(License license, String publicKey)
    {
        // create the crypto-service provider:
        DSACryptoServiceProvider dsa = new DSACryptoServiceProvider();

        // setup the provider from the public key:
        dsa.FromXmlString(publicKey);

        // get the license terms data:
        byte[] terms = Convert.FromBase64String(license.LicenseTerms);

        // get the signature data:
        byte[] signature = Convert.FromBase64String(license.Signature);

        // verify that the license-terms match the signature data
        if (dsa.VerifyData(terms, signature))
            return LicenseTerms.FromString(license.LicenseTerms);
        else
            throw new SecurityException("Signature Not Verified!");
    }

le condizioni di licenza Classe:

    /// <summary>
    /// terms of the license agreement: it's not encrypted (but is obscured)
    /// </summary>
    [Serializable]
    internal class LicenseTerms
    {
        /// <summary>
        /// start date of the license agreement.
        /// </summary>
        public DateTime StartDate { get; set; }

        /// <summary>
        /// registered user name for the license agreement.
        /// </summary>
        public String UserName { get; set; }

        /// <summary>
        /// the assembly name of the product that is licensed.
        /// </summary>
        public String ProductName { get; set; }

        /// <summary>
        /// the last date on which the software can be used on this license.
        /// </summary>
        public DateTime EndDate { get; set; }

        /// <summary>
        /// returns the license terms as an obscure (not human readable) string.
        /// </summary>
        /// <returns></returns>
        public String GetLicenseString()
        {
            using (MemoryStream ms = new MemoryStream())
            {
                // create a binary formatter:
                BinaryFormatter bnfmt = new BinaryFormatter();

                // serialize the data to the memory-steam;
                bnfmt.Serialize(ms, this);

                // return a base64 string representation of the binary data:
                return Convert.ToBase64String(ms.GetBuffer());

            }
        }

        /// <summary>
        /// returns a binary representation of the license terms.
        /// </summary>
        /// <returns></returns>
        public byte[] GetLicenseData()
        {
            using (MemoryStream ms = new MemoryStream())
            {
                // create a binary formatter:
                BinaryFormatter bnfmt = new BinaryFormatter();

                // serialize the data to the memory-steam;
                bnfmt.Serialize(ms, this);

                // return a base64 string representation of the binary data:
                return ms.GetBuffer();

            }
        }

        /// <summary>
        /// create a new license-terms object from a string-representation of the binary
        /// serialization of the licence-terms.
        /// </summary>
        /// <param name="licenseTerms"></param>
        /// <returns></returns>
        internal static LicenseTerms FromString(String licenseTerms)
        {

            using (MemoryStream ms = new MemoryStream(Convert.FromBase64String(licenseTerms)))
            {
                // create a binary formatter:
                BinaryFormatter bnfmt = new BinaryFormatter();

                // serialize the data to the memory-steam;
                object value = bnfmt.Deserialize(ms);

                if (value is LicenseTerms)
                    return (LicenseTerms)value;
                else
                    throw new ApplicationException("Invalid Type!");

            }
        }

    }

Answer 3

Tecnicamente, il suo compito non è facile per creare lavoro e sicuro sistema di licenze. Nel caso in cui si prevede di sviluppare software commerciale, mi sento di raccomandare di utilizzare una soluzione commerciale per esso. codificati personalizzato licenza sistemi tendono ad essere vulnerabili.

Ho migliore esperienza con Licensing Biblioteca di treek. Il suo basso costo anche per singolo sviluppatore, il suo sicuro e con un buon supporto. Quando si confrontano i costi, TLL è più conveniente che affittare il proprio sviluppatore di fare lo stesso lavoro.

Inoltre, è necessario proteggere le fonti. Per che noi utilizziamo EAZ Fuscator , ma ci sono anche opzioni gratuite disponibili. EAZ è molto buona, ma molto costoso.

Answer 4

Un approccio è quello di rotolare il proprio chiave parziale sistema di verifica . C'è una versione VB.NET disponibile sul Codice del progetto:

http://www.codeproject.com/KB/security/cdkeys.aspx

Answer 5

Diffidare di quanto impegno si mette in a proteggere la tua app; esso può essere sprecato tempo se è facilmente rotto o scoraggiante per gli utenti se molto forte (ad esempio dover inserire una password ogni volta che viene eseguito).

Un interessante articolo sulla protezione del software (giochi) può essere trovato qui: http://www.positech.co.uk/talkingtopirates.html