Giấy phép cho ứng dụng C# trên máy tính để bàn

Question

Làm cách nào để thêm giấy phép vào ứng dụng C# trên máy tính để bàn của tôi? Tôi cần phải tìm một phương pháp miễn phí phù hợp để ngăn người dùng trái phép cài đặt phần mềm của tôi.

Answer 1

Có rất nhiều hệ thống quản lý giấy phép ở đó cho .NET (thậm chí có một built-in for licensing controls). Một Google nhanh chóng xung quanh cho "quản lý giấy phép .NET" đã ném lên hệ thống Open License, miễn phí.

Tôi hy vọng bạn có thể dễ dàng tìm thấy nhiều hơn.

Answer 2

Một cách tiếp cận là cuộn partial key verification system của riêng bạn. Có một phiên bản VB.NET sẵn trên Mã số dự án:

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

Answer 3

Hãy cảnh giác với bao nhiêu nỗ lực bạn bỏ ra để bảo vệ ứng dụng của bạn; nó có thể bị lãng phí thời gian nếu nó dễ dàng bị phá vỡ hoặc tắt đưa cho người dùng nếu rất mạnh (ví dụ như phải nhập mật khẩu mỗi khi nó được chạy).

Một bài viết thú vị về bảo vệ phần mềm (game) có thể được tìm thấy ở đây: http://www.positech.co.uk/talkingtopirates.html

Answer 4

Chúng tôi sử dụng Eziriz .NET Reactor cho obfuscation và giao quyền sử dụng phần mềm thương mại của chúng tôi. Nó khá tốt và nó không đắt.

(tôi không có liên kết với eziriz nào, tôi chỉ là một khách hàng satified)

Edit: xin lỗi, thấy từ 'miễn phí' quá muộn

Answer 5

tôi có lẽ hơi muộn, nhưng tôi đã dành một chút thời gian để tìm ra một phương pháp nhanh chóng và hiệu quả để đảm bảo một ứng dụng C# nhỏ, và tôi muốn chia sẻ kết quả của mình.

Dường như bạn có thể xây dựng hệ thống cấp phép khá riêng, an toàn của bạn bằng cách sử dụng RSA một cách hợp lý dễ dàng. Rõ ràng, không có gì là chống đạn khi nói đến bảo vệ phần mềm (Nó giống như bảo vệ ngôi nhà của bạn từ kẻ trộm: báo động, chó sủa và hàng rào làm cho nó rắc rối hơn nó có giá trị, nhưng họ sẽ không ngăn chặn ai đó xác định để có được in)

Vì vậy, làm cho nó khó khăn hơn giá trị của nó là cụm từ chính trong bảo vệ phần mềm: nếu bạn đang cung cấp một ERP $ 1.000.000 hệ thống, bạn sẽ muốn có bảo vệ thực sự tốt được ủy quyền thông qua dịch vụ web (và người dùng trả nhiều tiền cho một hệ thống sẽ không gặp vấn đề với việc cho phép truy cập internet không đổi hệ thống)

Tuy nhiên, nếu bạn chỉ đang sạc $ 5- $ 30 cho một ứng dụng nhỏ, người dùng sẽ không đưa lên với ủy quyền rất nặng.

Tôi nghĩ rằng hệ thống đơn giản nhất để sản xuất là ký kỹ thuật số tệp giấy phép chứa chi tiết sản phẩm, người dùng và thời lượng của sản phẩm.

Điều này có nghĩa là bất kỳ sửa đổi nào của tệp giấy phép đều làm cho chữ ký số không hợp lệ.

Chữ ký số có thể lấy từ lớp DSACryptoServiceProvider, sử dụng phương thức SignData.

Một khóa bí mật được yêu cầu ký vào các dữ liệu, và phần nào của quan trọng mà có thể được sử dụng để xác nhận chữ ký: (do đó khóa công khai phải được truy cập bởi các ứng dụng)

Các DSAXCryptoServiceProvider có phương pháp để tạo và sử dụng các phím:

DSACryptoServiceProvider.ToXMLString (bool includePrivate);

trả về Public hoặc Public & Khóa cá nhân hiện có trong nhà cung cấp dịch vụ dưới dạng chuỗi XML.

DSACryptoServiceProvider.FromXMLString (String xmlString)

Phương pháp này thiết lập một DSACryptoServiceProvider mới có khóa riêng tư hay công cộng thu được từ DSACryptoServiceProvider.ToXMLString() hiện

Các lỗ hổng duy nhất trong sự an toàn của hệ thống này sẽ là khả năng người dùng vi phạm một khóa công khai của riêng họ. Điều này sẽ cho phép họ tạo các tệp giấy phép của riêng họ từ khóa riêng của họ.

Điều này có thể được giải quyết bằng cách ký thêm một tài nguyên cần thiết cho ứng dụng (như một .dll chứa logic cần thiết cho ứng dụng, hoặc thậm chí bản thân .exe) - do đó nếu khóa công khai bị thay đổi, bổ sung này (ẩn) chữ ký sẽ trở thành không hợp lệ. Các cách khác để cải thiện điều này bao gồm che khuất các điều khoản cấp phép (tuần tự hóa cấu trúc dữ liệu chứa các điều khoản cấp phép sử dụng trình định dạng nhị phân thành mảng byte, sau đó sử dụng Convert.ToBase64String() sẽ che khuất hiệu quả các điều khoản cấp phép. ngay cả khi người dùng có thể thay thế khóa công khai mà họ vẫn cần phải trình bày dữ liệu)

Tôi có một hệ thống ví dụ tôi đã viết, nhưng nó quá lớn để trích dẫn hoàn toàn, nhưng đây là Phương thức CreateLicense từ nó:

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

Phương thức xác minh:

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

Giấy phép Điều khoản Class:

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

      } 
     } 

    }