public void SetupTests() { license = new ClientLicense(); license.UniqueId = Guid.NewGuid(); license.LicenseSets = new NotifyList<LicenseSet>(); LicenseSet ls = new LicenseSet(); ls.SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser; ls.Name = "Standard License Set"; ls.UniquePad = new Guid(); license.LicenseSets.Add(ls); generationOptions = new LicenseGenerationOptions(); license.Product = new Product(); license.Product.Name = "My Great Uber Cool Product, with new juice!"; license.Product.ProductId = 1; packingService = new PackingService(numberDataGenerationProvider); clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider); clientLicenseService = new ClientLicenseService(clientLicenseRepository); string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X"); LicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider(asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider); staticKeyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider); licenseKeyService = new LicenseKeyService(staticKeyGenerator, packingService, clientLicenseService); }
public void Before_each_test() { asymmetricEncryptionProvider = new AsymmetricEncryptionProvider(); symmetricEncryptionProvider = new SymmetricEncryptionProvider(); hashingProvider = new HashingProvider(); smallKeyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider); license = new ClientLicense(); generationOptions = new LicenseGenerationOptions(); license.UniqueId = Guid.NewGuid(); license.Product = new Product(); license.Product.Name = "My Great Uber Cool Product, with new juice!"; license.Product.ProductId = 1; license.LicenseSets = new NotifyList<LicenseSet>(); license.LicenseSets.Add(new LicenseSet()); license.LicenseSets.First().SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser; license.LicenseSets.First().SupportedLicenseTypes |= LicenseKeyTypeFlag.Enterprise; license.LicenseSets.First().SupportedLicenseTypes |= LicenseKeyTypeFlag.Unlimited; generationOptions.LicenseKeyType = LicenseKeyTypes.Enterprise; string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X"); placeholders = smallKeyGenerator.CreateLicensePlaceholders(license, generationOptions); placeholdersInTemplate = KeyGenerator.FindAllPlaceholdersInTemplate(KeyGenerator.licenseKeyTemplate, placeholders); key = smallKeyGenerator.GenerateLicenseKey("TEST", license, generationOptions); }
public ClientLicense ActivateLicenseKey(string licenseKey, Guid? token, bool isOffline, ClientLicense scutexLicense) { /* This method used to live in the LicenseKeyService class, where it should be * but because of a circular reference in the WebServicesProvider and the ServicesLibrary * project requiring the LicenseKeyService to valid keys it was causing and error and had * to be moved here. */ if (_licenseKeyService.ValidateLicenseKey(licenseKey, scutexLicense, true)) { Token t = new Token(); t.Data = scutexLicense.ServiceToken; t.Timestamp = DateTime.Now; string packedToken = _packingService.PackToken(t); LicenseActivationPayload payload = new LicenseActivationPayload(); payload.LicenseKey = licenseKey; payload.ServiceLicense = new ServiceLicense(scutexLicense); payload.Token = token; if (!isOffline) { ActivationResult result = _licenseActiviationProvider.ActivateLicense(scutexLicense.ServiceAddress, packedToken, GetClientStandardEncryptionInfo(scutexLicense), payload, scutexLicense); if (result != null && result.WasRequestValid && result.ActivationSuccessful) { scutexLicense.IsLicensed = true; scutexLicense.IsActivated = true; scutexLicense.ActivatingServiceId = result.ServiceId; scutexLicense.ActivationToken = result.ActivationToken; scutexLicense.ActivatedOn = DateTime.Now; scutexLicense.ActivationLastCheckedOn = DateTime.Now; _clientLicenseService.SaveClientLicense(scutexLicense); return scutexLicense; } } else { scutexLicense.IsLicensed = true; scutexLicense.IsActivated = false; scutexLicense.ActivatingServiceId = null; scutexLicense.ActivationToken = null; scutexLicense.ActivatedOn = DateTime.Now; scutexLicense.ActivationLastCheckedOn = DateTime.Now; _clientLicenseService.SaveClientLicense(scutexLicense); return scutexLicense; } } return scutexLicense; }
public MoreInfoContent(ClientLicense clientLicense) : this() { _clientLicense = clientLicense; btnBuyNowUrl.Content = _clientLicense.BuyNowUrl; btnHomepage.Content = _clientLicense.ProductUrl; btnEulaUrl.Content = _clientLicense.EulaUrl; }
internal EncryptionInfo GetClientStandardEncryptionInfo(ClientLicense clientLicense) { EncryptionInfo ei = new EncryptionInfo(); ei.HashAlgorithm = "SHA1"; ei.InitVector = Resources.ServicesIV; ei.Iterations = 2; ei.KeySize = 192; ei.PassPhrase = clientLicense.Ces1; ei.SaltValue = clientLicense.Ces2; return ei; }
public LicenseWindow(object licensingManager, ScutexLicense scutexLicense, ClientLicense clientLicense) { InitializeComponent(); _clientLicense = clientLicense; _licensingManager = licensingManager as LicensingManager; _scutexLicense = scutexLicense; SetIcon(); SetWindowIcon(); SetFormData(); SetFormDisplay(); SetTrialDelayTimer(); }
public ActivationResult ActivateLicense(string url, string token, EncryptionInfo encryptionInfo, LicenseActivationPayload payload, ClientLicense clientLicense) { ActivationServiceClient client = ActivationServiceClientCreator(url); string encryptedToken = _symmetricEncryptionProvider.Encrypt(token, encryptionInfo); string serializedPayload = _objectSerializationProvider.Serialize(payload); string encryptedData = _asymmetricEncryptionProvider.EncryptPrivate(serializedPayload, clientLicense.ServicesKeys); string serviceResult = client.ActivateLicense(encryptedToken, encryptedData); string result = _asymmetricEncryptionProvider.DecryptPublic(serviceResult, clientLicense.ServicesKeys); ActivationResult activationResult = _objectSerializationProvider.Deserialize<ActivationResult>(result); return activationResult; }
public RegisterContent(ClientLicense clientLicense, ScutexLicense scutexLicense) : this() { _clientLicense = clientLicense; _scutexLicense = scutexLicense; switch (_clientLicense.KeyGeneratorType) { case KeyGeneratorTypes.StaticSmall: txtLicenseKey.InputMask = @"www-wwwwww-wwww"; break; case KeyGeneratorTypes.StaticLarge: txtLicenseKey.InputMask = @"wwwww-wwwww-wwwww-wwwww-wwwww"; break; } }
public ClientLicense SaveClientLicense(ClientLicense clientLicense, string filePath) { if (File.Exists(filePath)) File.Delete(filePath); string plainTextObjectData; plainTextObjectData = objectSerializationProvider.Serialize(clientLicense); string encryptedObjectData; encryptedObjectData = encryptionProvider.Encrypt(plainTextObjectData, encryptionInfo); using (StreamWriter writer = new StreamWriter(filePath)) { writer.Write(encryptedObjectData); } return GetClientLicense(filePath); }
private void btnGetDataFile_Click(object sender, RoutedEventArgs e) { SaveFileDialog dialog = new SaveFileDialog(); dialog.FileName = "sxu.dll"; dialog.DefaultExt = ".dll"; dialog.Filter = "DLL Files (.dll)|*.dll"; dialog.ShowDialog(); if (!String.IsNullOrEmpty(dialog.FileName)) { ClientLicense cl = new ClientLicense(UIContext.License); string fileName = System.IO.Path.GetFileName(dialog.FileName); if (fileName != "sxu.dll") { MessageBox.Show("This version of Scutex only supports a data file with the name of sxu.dll."); return; } IClientLicenseService clientLicenseService = ObjectLocator.GetInstance<IClientLicenseService>(); clientLicenseService.SaveClientLicense(cl, dialog.FileName); } }
public ClientLicense SaveClientLicense(ClientLicense clientLicense, string filePath) { return _clientLicenseRepository.SaveClientLicense(clientLicense, filePath); }
public static void SmallLicenseKeyWithLessThen15CharsTest() { IAsymmetricEncryptionProvider asymmetricEncryptionProvider; ISymmetricEncryptionProvider symmetricEncryptionProvider; IHashingProvider hashingProvider; WaveTech.Scutex.Generators.StaticKeyGeneratorSmall.KeyGenerator smallKeyGenerator; ClientLicense license; LicenseGenerationOptions generationOptions; //List<LicensePlaceholder> placeholders; //Dictionary<int, LicensePlaceholder> placeholdersInTemplate; for (int i = 0; i < 100000; i++) { asymmetricEncryptionProvider = new AsymmetricEncryptionProvider(); symmetricEncryptionProvider = new SymmetricEncryptionProvider(); hashingProvider = new HashingProvider(); smallKeyGenerator = new WaveTech.Scutex.Generators.StaticKeyGeneratorSmall.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider); license = new ClientLicense(); generationOptions = new LicenseGenerationOptions(); license.UniqueId = Guid.NewGuid(); license.Product = new Product(); license.Product.Name = "My Great Uber Cool Product, with new juice!"; license.Product.ProductId = 1; license.LicenseSets = new NotifyList<LicenseSet>(); license.LicenseSets.Add(new LicenseSet()); license.LicenseSets.First().SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser; license.LicenseSets.First().SupportedLicenseTypes |= LicenseKeyTypeFlag.Enterprise; license.LicenseSets.First().SupportedLicenseTypes |= LicenseKeyTypeFlag.Unlimited; generationOptions.LicenseKeyType = LicenseKeyTypes.Enterprise; string key = smallKeyGenerator.GenerateLicenseKey("TEST", license, generationOptions); if (key.Length < 15) { string error = key; Console.WriteLine("ERROR: " + error); } Console.WriteLine(key); } }
public static void BatchSmallLicenseKeyGenrationTest() { IAsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider(); ISymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider(); IHashingProvider hashingProvider = new HashingProvider(); IObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider(); ILicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider( asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider); INumberDataGeneratorProvider numberDataGeneratorProvider = new NumberDataGenerator(); IPackingService packingService = new PackingService(numberDataGeneratorProvider); IHardwareFingerprintService hardwareFingerprintService = new HardwareFingerprintService(new WmiDataProvider(), hashingProvider); IClientLicenseRepository clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider); IClientLicenseService clientLicenseService = new ClientLicenseService(clientLicenseRepository); ISmallKeyGenerator smallKeyGenerator = new WaveTech.Scutex.Generators.StaticKeyGeneratorSmall.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider); ILargeKeyGenerator staticKeyGeneratorLarge = new WaveTech.Scutex.Generators.StaticKeyGeneratorLarge.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, hardwareFingerprintService); LicenseKeyService licenseKeyService = new LicenseKeyService(smallKeyGenerator, staticKeyGeneratorLarge, packingService, clientLicenseService); ClientLicense license = new ClientLicense(); LicenseGenerationOptions generationOptions = new LicenseGenerationOptions(); license.UniqueId = Guid.NewGuid(); license.Product = new Product(); license.Product.Name = "My Great Uber Cool Product, with new juice!"; license.Product.ProductId = 1; string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X"); DateTime start = DateTime.Now; List<string> licenseKeys = licenseKeyService.GenerateLicenseKeys("TEST", license, generationOptions, 100000); Dictionary<string, string> doubleCheck = new Dictionary<string, string>(); DateTime end = DateTime.Now; foreach (string s in licenseKeys) { doubleCheck.Add(s, ""); Console.WriteLine(s); } Console.WriteLine(); Console.WriteLine("================================="); Console.WriteLine(string.Format("Key Generation took {0}", end - start)); Console.WriteLine(string.Format("Generated {0} unique license keys", licenseKeys.Count)); Console.WriteLine(); Console.WriteLine("Press enter to exit."); Console.ReadLine(); }
public ScutexLicense Validate(string licenseKey, ScutexLicense scutexLicense, ClientLicense clientLicense) { return scutexLicense; }
public static void LicenseKeyGenerationTest() { IAsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider(); ISymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider(); IHashingProvider hashingProvider = new HashingProvider(); IObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider(); ILicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider( asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider); INumberDataGeneratorProvider numberDataGeneratorProvider = new NumberDataGenerator(); IPackingService packingService = new PackingService(numberDataGeneratorProvider); IHardwareFingerprintService hardwareFingerprintService = new HardwareFingerprintService(new WmiDataProvider(), hashingProvider); IClientLicenseRepository clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider); IClientLicenseService clientLicenseService = new ClientLicenseService(clientLicenseRepository); KeyGenerator staticKeyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider); ILargeKeyGenerator staticKeyGeneratorLarge = new WaveTech.Scutex.Generators.StaticKeyGeneratorLarge.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, hardwareFingerprintService); LicenseKeyService licenseKeyService = new LicenseKeyService(staticKeyGenerator, staticKeyGeneratorLarge, packingService, clientLicenseService); ClientLicense license = new ClientLicense(); LicenseGenerationOptions generationOptions = new LicenseGenerationOptions(); license.UniqueId = Guid.NewGuid(); license.Product = new Product(); license.Product.Name = "My Great Uber Cool Product, with new juice!"; license.Product.ProductId = 1; string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X"); Dictionary<string, string> licenseKeys = new Dictionary<string, string>(); DateTime start = DateTime.Now; for (int i = 0; i < 100000; i++) { string key = licenseKeyService.GenerateLicenseKey("TEST", license, generationOptions); licenseKeys.Add(key, key.GetHashCode().ToString()); Console.WriteLine(key); } DateTime end = DateTime.Now; Console.WriteLine(start - end); }
public static void SmallLicenseKeyGenrationTest() { IAsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider(); ISymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider(); IHashingProvider hashingProvider = new HashingProvider(); IObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider(); ILicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider( asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider); INumberDataGeneratorProvider numberDataGeneratorProvider = new NumberDataGenerator(); IPackingService packingService = new PackingService(numberDataGeneratorProvider); IClientLicenseRepository clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider); IClientLicenseService clientLicenseService = new ClientLicenseService(clientLicenseRepository); IKeyGenerator smallKeyGenerator = new WaveTech.Scutex.Generators.StaticKeyGeneratorSmall.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider); LicenseKeyService licenseKeyService = new LicenseKeyService(smallKeyGenerator, packingService, clientLicenseService); ClientLicense license = new ClientLicense(); LicenseGenerationOptions generationOptions = new LicenseGenerationOptions(); license.UniqueId = Guid.NewGuid(); license.Product = new Product(); license.Product.Name = "My Great Uber Cool Product, with new juice!"; license.Product.ProductId = 1; string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X"); Dictionary<string, string> licenseKeys = new Dictionary<string, string>(); DateTime start = DateTime.Now; try { List<string> keys = licenseKeyService.GenerateLicenseKeys("TEST", license, generationOptions, 100000); foreach (string key in keys) { string hash = hashingProvider.ComputeHash(key, "SHA256"); licenseKeys.Add(hash, key); Console.WriteLine(key); Console.WriteLine(hash + " " + hash.Equals(hashingProvider.ComputeHash(key, "SHA256"))); } } catch (Exception ex) { Console.WriteLine(ex.Message); } finally { Console.WriteLine(); Console.WriteLine("================================="); DateTime end = DateTime.Now; Console.WriteLine(string.Format("Key Generation took {0}", end - start)); Console.WriteLine(string.Format("Generated {0} unique license keys", licenseKeys.Count)); Console.WriteLine(); Console.WriteLine("Press enter to exit."); Console.ReadLine(); } }
public void TestLicenseKeyHashing() { IAsymmetricEncryptionProvider asymmetricEncryptionProvider = new AsymmetricEncryptionProvider(); ISymmetricEncryptionProvider symmetricEncryptionProvider = new SymmetricEncryptionProvider(); IHashingProvider hashingProvider = new HashingProvider(); IObjectSerializationProvider objectSerializationProvider = new ObjectSerializationProvider(); ILicenseActiviationProvider licenseActiviationProvider = new LicenseActiviationProvider( asymmetricEncryptionProvider, symmetricEncryptionProvider, objectSerializationProvider); INumberDataGeneratorProvider numberDataGeneratorProvider = new NumberDataGenerator(); IPackingService packingService = new PackingService(numberDataGeneratorProvider); IClientLicenseRepository clientLicenseRepository = new ClientLicenseRepository(objectSerializationProvider, symmetricEncryptionProvider); IClientLicenseService clientLicenseService = new ClientLicenseService(clientLicenseRepository); IKeyGenerator smallKeyGenerator = new WaveTech.Scutex.Generators.StaticKeyGeneratorSmall.KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider); LicenseKeyService licenseKeyService = new LicenseKeyService(smallKeyGenerator, packingService, clientLicenseService); ClientLicense license = new ClientLicense(); LicenseGenerationOptions generationOptions = new LicenseGenerationOptions(); license.UniqueId = Guid.NewGuid(); license.Product = new Product(); license.Product.Name = "My Great Uber Cool Product, with new juice!"; license.Product.ProductId = 1; string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X"); Dictionary<string, string> licenseKeys = new Dictionary<string, string>(); List<string> keys = licenseKeyService.GenerateLicenseKeys("TEST", license, generationOptions, 100000); foreach (string key in keys) { string hash = hashingProvider.ComputeHash(key, "SHA256"); licenseKeys.Add(hash, key); Console.WriteLine(key + "\t" + hash); Assert.IsTrue(hash.Equals(hashingProvider.ComputeHash(key, "SHA256"))); Assert.IsFalse(hash.Contains("'")); } }
public void CreateFile(ClientLicense license) { string path = Helper.AssemblyDirectory; if (File.Exists(path + "\\sxu.dll")) File.Delete(path + "\\sxu.dll"); clientLicenseService.SaveClientLicense(license, path + "\\sxu.dll"); }
public void InvalidTrialSetup() { License.Name = "UnitTest License"; Product p = new Product(); p.Name = "UnitTest Product"; p.Description = "Just a product for unit testing"; License.LicenseId = 1; License.Product = p; License.KeyGeneratorType = KeyGeneratorTypes.StaticSmall; LicenseTrialSettings ts = new LicenseTrialSettings(); ts.ExpirationOptions = TrialExpirationOptions.Days; ts.ExpirationData = "30"; License.TrialSettings = ts; LicenseSet ls = new LicenseSet(); ls.LicenseId = 1; ls.LicenseSetId = 1; ls.Name = "Unit Test License Set"; ls.MaxUsers = 5; ls.SupportedLicenseTypes = LicenseKeyTypeFlag.Enterprise; License.LicenseSets = new NotifyList<LicenseSet>(); License.LicenseSets.Add(ls); ClientLicense lic2 = new ClientLicense(License); lic2.RunCount = 10; lic2.LastRun = DateTime.Now.AddMonths(12); lic2.FirstRun = DateTime.Now.AddMonths(24); CreateFile(lic2); }
internal EncryptionInfo GetClientStandardEncryptionInfo(ClientLicense clientLicense) { EncryptionInfo ei = new EncryptionInfo(); ei.HashAlgorithm = "SHA1"; ei.InitVector = Resources.ServicesIV; ei.Iterations = 2; ei.KeySize = 192; // Outbound Key string outKey1 = clientLicense.ServicesKeys.PrivateKey.Substring(0, (clientLicense.ServicesKeys.PrivateKey.Length / 2)); string outKey2 = clientLicense.ServicesKeys.PrivateKey.Substring(outKey1.Length, (clientLicense.ServicesKeys.PrivateKey.Length - outKey1.Length)); // Inbound Key string inKey1 = clientLicense.ServicesKeys.PublicKey.Substring(0, (clientLicense.ServicesKeys.PublicKey.Length / 2)); string inKey2 = clientLicense.ServicesKeys.PublicKey.Substring(inKey1.Length, (clientLicense.ServicesKeys.PublicKey.Length - inKey1.Length)); ei.PassPhrase = outKey2; ei.SaltValue = inKey2; return ei; }
public ScutexLicense GetScutexLicense(ClientLicense clientLicense) { ScutexLicense scutexLicense = new ScutexLicense(); scutexLicense.TrialFaultReason = TrialFaultReasons.None; scutexLicense.IsTrialValid = true; scutexLicense.LastRun = clientLicense.LastRun; scutexLicense.TrialSettings = clientLicense.TrialSettings; scutexLicense.TrailNotificationSettings = clientLicense.TrailNotificationSettings; scutexLicense.IsCommunityEdition = ApplicationConstants.IsCommunityEdition; if (!clientLicense.FirstRun.HasValue) { Logging.LogDebug(string.Format("Is First Run!")); clientLicense.FirstRun = _networkTimeProvider.GetNetworkTime(); scutexLicense.WasTrialFristRun = true; Logging.LogDebug(string.Format("FirstRun SetTo: {0}", clientLicense.FirstRun.Value)); } else { Logging.LogDebug(string.Format("Is Existing Run!")); Logging.LogDebug(string.Format("FirstRun Date: {0}", clientLicense.FirstRun.Value)); Logging.LogDebug(string.Format("NetTime Date: {0}", _networkTimeProvider.GetNetworkTime())); } if (clientLicense.LastRun.HasValue && _networkTimeProvider.GetNetworkTime() < clientLicense.LastRun) { Logging.LogDebug(string.Format("TIME FAULT")); Logging.LogDebug(string.Format("LastRun Date: {0}", clientLicense.LastRun.Value)); Logging.LogDebug(string.Format("NetRun Date: {0}", _networkTimeProvider.GetNetworkTime())); Logging.LogDebug(string.Format("Delta: {0}", (_networkTimeProvider.GetNetworkTime() - clientLicense.LastRun.Value))); scutexLicense.IsTrialValid = false; scutexLicense.TrialFaultReason = TrialFaultReasons.TimeFault; } clientLicense.LastRun = _networkTimeProvider.GetNetworkTime(); Logging.LogDebug(string.Format("Old Run Count: {0}", clientLicense.RunCount)); clientLicense.RunCount++; Logging.LogDebug(string.Format("New Run Count: {0}", clientLicense.RunCount)); scutexLicense.FirstRun = clientLicense.FirstRun; switch (clientLicense.TrialSettings.ExpirationOptions) { case TrialExpirationOptions.Days: TimeSpan ts = clientLicense.FirstRun.Value - _networkTimeProvider.GetNetworkTime().AddDays(-int.Parse(clientLicense.TrialSettings.ExpirationData)); scutexLicense.TrialRemaining = ts.Days; if (ts.Days <= 0) { scutexLicense.IsTrialExpired = true; Logging.LogDebug(string.Format("Trial Expired")); } else { scutexLicense.IsTrialExpired = false; Logging.LogDebug(string.Format("Trial Not Expired")); } break; } // TODO: Need to set a fair amount of data here, like licensed edition, level, etc if (clientLicense.IsLicensed) { scutexLicense.IsLicensed = clientLicense.IsLicensed; Logging.LogDebug(string.Format("Product is licensed")); } else { Logging.LogDebug(string.Format("Product is not licensed")); } Logging.LogDebug(string.Format("Saving client license")); _clientLicenseService.SaveClientLicense(clientLicense); return scutexLicense; }
public void Before_each_test() { asymmetricEncryptionProvider = new AsymmetricEncryptionProvider(); symmetricEncryptionProvider = new SymmetricEncryptionProvider(); hashingProvider = new HashingProvider(); var mock = new Mock<IHardwareFingerprintService>(); mock.Setup(foo => foo.GetHardwareFingerprint(FingerprintTypes.Default)).Returns("JustATestFingerprint1050"); _hardwareFingerprintService = new HardwareFingerprintService(new WmiDataProvider(), hashingProvider); largeKeyGenerator = new KeyGenerator(symmetricEncryptionProvider, asymmetricEncryptionProvider, hashingProvider, mock.Object); license = new ClientLicense(); generationOptions = new List<LicenseGenerationOptions>(); generationOptions.Add(new LicenseGenerationOptions()); generationOptions.Add(new LicenseGenerationOptions()); generationOptions.Add(new LicenseGenerationOptions()); generationOptions.Add(new LicenseGenerationOptions()); generationOptions.Add(new LicenseGenerationOptions()); generationOptions.Add(new LicenseGenerationOptions()); license.UniqueId = Guid.NewGuid(); license.Product = new Product(); license.Product.Name = "My Great Uber Cool Product, with new juice!"; license.Product.ProductId = 1; license.LicenseSets = new NotifyList<LicenseSet>(); license.LicenseSets.Add(new LicenseSet()); license.LicenseSets.Add(new LicenseSet()); license.LicenseSets.Add(new LicenseSet()); license.LicenseSets.Add(new LicenseSet()); license.LicenseSets.Add(new LicenseSet()); license.LicenseSets[0].LicenseSetId = 1; license.LicenseSets[0].Name = "Standard Edition"; license.LicenseSets[0].MaxUsers = 5; license.LicenseSets[0].SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser; license.LicenseSets[0].SupportedLicenseTypes |= LicenseKeyTypeFlag.MultiUser; license.LicenseSets[0].SupportedLicenseTypes |= LicenseKeyTypeFlag.Unlimited; license.LicenseSets[1].LicenseSetId = 2; license.LicenseSets[1].Name = "Professional Edition"; license.LicenseSets[1].MaxUsers = 5; license.LicenseSets[1].SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser; license.LicenseSets[1].SupportedLicenseTypes |= LicenseKeyTypeFlag.MultiUser; license.LicenseSets[1].SupportedLicenseTypes |= LicenseKeyTypeFlag.Unlimited; license.LicenseSets[2].LicenseSetId = 3; license.LicenseSets[2].Name = "Enterprise Edition"; license.LicenseSets[2].MaxUsers = 5; license.LicenseSets[2].SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser; license.LicenseSets[2].SupportedLicenseTypes |= LicenseKeyTypeFlag.MultiUser; license.LicenseSets[2].SupportedLicenseTypes |= LicenseKeyTypeFlag.Unlimited; license.LicenseSets[2].SupportedLicenseTypes |= LicenseKeyTypeFlag.Enterprise; license.LicenseSets[3].LicenseSetId = 4; license.LicenseSets[3].Name = "Upgrade Edition"; license.LicenseSets[3].MaxUsers = 0; license.LicenseSets[3].IsUpgradeOnly = true; license.LicenseSets[3].SupportedLicenseTypes = LicenseKeyTypeFlag.SingleUser; license.LicenseSets[4].LicenseSetId = 5; license.LicenseSets[4].Name = "Hardware Edition"; license.LicenseSets[4].MaxUsers = 0; license.LicenseSets[4].IsUpgradeOnly = false; license.LicenseSets[4].SupportedLicenseTypes = LicenseKeyTypeFlag.HardwareLock; generationOptions[0].LicenseKeyType = LicenseKeyTypes.SingleUser; generationOptions[0].LicenseSetId = 1; generationOptions[1].LicenseKeyType = LicenseKeyTypes.Enterprise; generationOptions[1].LicenseSetId = 2; generationOptions[2].LicenseKeyType = LicenseKeyTypes.Enterprise; generationOptions[2].LicenseSetId = 3; generationOptions[3].LicenseKeyType = LicenseKeyTypes.Enterprise; generationOptions[3].LicenseSetId = 4; generationOptions[4].LicenseKeyType = LicenseKeyTypes.HardwareLock; generationOptions[4].HardwareFingerprint = "JustATestFingerprint1050"; generationOptions[4].LicenseSetId = 5; generationOptions[5].LicenseKeyType = LicenseKeyTypes.HardwareLockLocal; generationOptions[5].HardwareFingerprint = "JustATestFingerprint1050"; generationOptions[5].LicenseSetId = 5; string productHash = hashingProvider.Checksum32(license.GetLicenseProductIdentifier()).ToString("X"); placeholders = largeKeyGenerator.CreateLicensePlaceholders(license, generationOptions[0]); placeholdersInTemplate = KeyGenerator.FindAllPlaceholdersInTemplate(KeyGenerator.licenseKeyTemplate, placeholders); key = largeKeyGenerator.GenerateLicenseKey("TEST", license, generationOptions[0]); }
public ClientLicense SaveClientLicense(ClientLicense clientLicense) { return _clientLicenseRepository.SaveClientLicense(clientLicense); }
private static void Demo(object sender, ExecutedRoutedEventArgs e) { if (UIContext.License != null) { DemoHostHelper helper = new DemoHostHelper(); helper.CleanPreviousHost(); string path = Path.GetDirectoryName(Assembly.GetExecutingAssembly().GetName().CodeBase); path = path.Replace("file:\\", ""); ClientLicense cl = new ClientLicense(UIContext.License); IClientLicenseService clientLicenseService = ObjectLocator.GetInstance<IClientLicenseService>(); clientLicenseService.SaveClientLicense(cl, path + @"\sxu.dll"); IHashingProvider hashingProvider = ObjectLocator.GetInstance<IHashingProvider>(); IEncodingService encodingService = ObjectLocator.GetInstance<IEncodingService>(); string dllCheckHash = encodingService.Encode(hashingProvider.HashFile(Directory.GetCurrentDirectory() + "\\lib\\WaveTech.Scutex.Licensing.dll")); string publicKey = encodingService.Encode(UIContext.License.KeyPair.PublicKey); try { File.Copy(Directory.GetCurrentDirectory() + "\\lib\\WaveTech.Scutex.Licensing.dll", Directory.GetCurrentDirectory() + "\\WaveTech.Scutex.Licensing.dll"); } catch { } helper.CreateAssembly(publicKey, dllCheckHash); helper.ExecuteAssembly(); helper = null; } else { MessageBox.Show("You must have an open licensing project to view the demo trial form."); } }
internal ClientLicense CreateTestClientLicense(Service service) { ClientLicense cl = new ClientLicense(); cl.ServicesKeys = service.GetClientServiceKeyPair(); cl.Product = new Product(); cl.Product.Name = "Test Product"; cl.LicenseSets = new NotifyList<LicenseSet>(); LicenseSet ls = new LicenseSet(); ls.LicenseId = int.MaxValue; ls.LicenseSetId = int.MaxValue; ls.Name = "Test Product License Set"; ls.MaxUsers = 2; ls.SupportedLicenseTypes = LicenseKeyTypeFlag.MultiUser; cl.LicenseSets.Add(ls); return cl; }
public ClientLicense SaveClientLicense(ClientLicense clientLicense) { return SaveClientLicense(clientLicense, Name); }