private static string EncryptString(Rsa rsaKey, string value) { Debug.Assert(rsaKey != null); Debug.Assert(!string.IsNullOrEmpty(value)); byte[] bytes = Encoding.UTF8.GetBytes(value); byte[] encryptedBytes = rsaKey.Encrypt(bytes); return(LicenseManager.BytesToString(encryptedBytes)); }
private static string DecryptString(Rsa rsaKey, string encryptedText) { Debug.Assert(rsaKey != null); Debug.Assert(!string.IsNullOrEmpty(encryptedText)); byte[] encryptedBytes = LicenseManager.BytesFromString(encryptedText); byte[] decryptedBytes = rsaKey.Decrypt(encryptedBytes); return(Encoding.UTF8.GetString(decryptedBytes)); }
/// <summary>Gets a license for specified assembly, given specified design time or runtime mode.</summary> /// <param name="assembly">The specified assembly.</param> /// <param name="designMode">Specifies the design time or runtime mode. <see langword="true" /> for design time, otherwise runtime.</param> /// <returns>A <see cref="License" /> object, or <see langword="null" /> for the assembly is not licensed.</returns> /// <remarks>The returned <see cref="License" /> object may not be able to be granted as a valid license. Call /// <see href="xref:DevZest.Licensing.LicenseManager.Check*">LicenseManager.Check</see> method to determine whether a /// valid license can be granted.</remarks> /// <exception cref="ArgumentNullException"><paramref name="assembly" /> is <see langword="null"/>.</exception> public static License GetLicense(Assembly assembly, bool designMode) { if (assembly == null) { throw new ArgumentNullException("assembly"); } LicenseManager manager = GetLicenseManager(assembly); return(manager.ProvideLicense(designMode)); }
private static string GetAssemblyHash(Assembly assembly) { foreach (object obj in GetEnumerable(assembly.Evidence.GetHostEnumerator())) { Hash hash = obj as Hash; if (hash != null) { return(LicenseManager.BytesToString(hash.SHA1)); } } return(null); }
/// <summary>Gets <see cref="License" /> from <see cref="LicensePublisher" /> using specified culture.</summary> /// <param name="cultureInfo">The specified culture information.</param> /// <param name="product">The product name.</param> /// <param name="version">The product version.</param> /// <param name="licenseKey">The license key.</param> /// <param name="category">The license category.</param> /// <param name="name">The user name.</param> /// <param name="company">The user company.</param> /// <param name="email">The user email address.</param> /// <param name="data">The data to set in the license.</param> /// <returns>The response from <see cref="LicensePublisher" /> which encapsulates a <see cref="License" /> object or /// an error message.</returns> public LicensePublisherResponse GetLicense(CultureInfo cultureInfo, string product, Version version, LicenseKey licenseKey, string category, string name, string company, string email, string data) { string encryptedResponse = base.Channel.Publish(cultureInfo.LCID, product, version.ToString(), licenseKey.EncryptToString(PublicKey), category, name, company, email, data); string response = licenseKey.Decrypt(encryptedResponse); if (response.StartsWith(ErrorHeader, StringComparison.Ordinal)) { string errorMessage = response.Substring(ErrorHeader.Length, response.Length - ErrorHeader.Length); return(new LicensePublisherResponse(errorMessage)); } else { return(new LicensePublisherResponse(LicenseManager.VerifySignedLicense(PublicKey, response))); } }
protected sealed override LicenseError Validate() { if (_verified) { Byte[] encryptedBytes = LicenseManager.BytesFromString(Data); Byte[] bytes = ProtectedData.Unprotect(encryptedBytes, null, DataProtectionScope.LocalMachine); if (new Guid(bytes) != Guid) { _error = new LicenseError(Assembly, LicenseErrorReason.InvalidLicense, Messages.InvalidMachineData, this); } _verified = true; } return(_error); }
public static void Reset(Assembly assembly) { if (assembly == null) { throw new ArgumentNullException("assembly"); } if (s_managers.ContainsKey(assembly)) { LicenseManager manager = s_managers[assembly]; Debug.Assert(manager != null); bool succeed = s_managers.Remove(assembly); Debug.Assert(succeed); } }
internal string Decrypt(string encryptedText) { if (IsEmpty) { Byte[] bytes = Convert.FromBase64String(encryptedText); return(Encoding.UTF8.GetString(bytes)); } byte[] input = LicenseManager.BytesFromString(encryptedText); byte[] output; using (TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider()) { output = Transform(input, des.CreateDecryptor(GetTripleDesKey(_key), GetTripleDesIv(_key))); } return(Encoding.UTF8.GetString(output)); }
internal string Encrypt(string text) { byte[] input = Encoding.UTF8.GetBytes(text); if (IsEmpty) { return(Convert.ToBase64String(input)); } byte[] output; using (TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider()) { output = Transform(input, des.CreateEncryptor(GetTripleDesKey(_key), GetTripleDesIv(_key))); } return(LicenseManager.BytesToString(output)); }
private License LoadLicense(string license, object providerData) { if (string.IsNullOrEmpty(license)) { return(null); } Assembly assembly = Assembly; string publicKeyXml = PublicKeyXmlFromAssembly(assembly); if (string.IsNullOrEmpty(publicKeyXml)) { throw new InvalidOperationException(ExceptionMessages.FormatNullPublicKey(assembly)); } using (Rsa publicKey = new Rsa(publicKeyXml)) { License result = (License)LicenseManager.VerifySignedLicense(publicKey, license); result.ProviderData = providerData; return(result); } }
private static LicenseManager GetLicenseManager(Assembly assembly) { Debug.Assert(assembly != null); LicenseManager manager; if (Managers.ContainsKey(assembly)) { manager = Managers[assembly]; // Check Manager.Assembly to prevent it being changed by reflection if (manager.Assembly != assembly) { throw new InvalidOperationException(); } return(manager); } manager = new LicenseManager(assembly); Managers.Add(assembly, manager); return(manager); }
public string Publish(int culture, string product, string version, string encryptedLicenseKey, string category, string name, string company, string email, string data) { Rsa privateKey = GetPrivateKey(product); if (privateKey == null) { throw new InvalidOperationException(ExceptionMessages.FormatNullPrivateKey(product)); } string responseString; LicenseKey licenseKey; try { licenseKey = LicenseKey.DecryptFromString(privateKey, encryptedLicenseKey); LicensePublisherResponse response = GetLicense(new CultureInfo(culture), product, new Version(version), licenseKey, category, name, company, email, data); License license = response.License; if (license == null) { responseString = LicenseClient.ErrorHeader + response.ErrorMessage; } else { responseString = LicenseManager.SignLicense(privateKey, license); } } finally { if (!_cachePrivateKey) { ((IDisposable)privateKey).Dispose(); } } return(licenseKey.Encrypt(responseString)); }
/// <summary>Gets the private key XML string from Strong Name Key (.snk) stream.</summary> /// <param name="stream">The stream of .snk file.</param> /// <returns>The private key XML string.</returns> public static string PrivateKeyXmlFromSnkFile(Stream stream) { return(LicenseManager.PrivateKeyXmlFromSnkFile(stream)); }
/// <overloads>Gets the private key XML string from Strong Name Key (.snk) file or stream.</overloads> /// <summary>Gets the private key XML string from Strong Name Key (.snk) file.</summary> /// <param name="snkFilePath">Full path and name of the .snk file.</param> /// <returns>The private key XML string.</returns> public static string PrivateKeyXmlFromSnkFile(string snkFilePath) { return(LicenseManager.PrivateKeyXmlFromSnkFile(snkFilePath)); }
/// <overloads>Gets public key XML string from specified assembly.</overloads> /// <summary>Gets public key XML string from specified assembly.</summary> /// <param name="assembly">The specified assembly.</param> /// <returns>The public key XML. <see langword="null" /> if assembly is not signed with a strong name.</returns> public static string PublicKeyXmlFromAssembly(Assembly assembly) { return(LicenseManager.PublicKeyXmlFromAssembly(assembly)); }
internal void Freeze(LicenseManager manager) { System.Diagnostics.Debug.Assert(manager != null); _manager = manager; }
/// <summary>Gets public key XML string from specified assembly file.</summary> /// <param name="assemblyPath">The full path of the assembly file.</param> /// <returns>The public key XML. <see langword="null" /> if assembly is not signed with a strong name.</returns> public static string PublicKeyXmlFromAssembly(string assemblyPath) { return(LicenseManager.PublicKeyXmlFromAssembly(assemblyPath)); }