private XmlDocument CreateLicenseDocument(LicenseCriteria licenseCriteria) { var licenseDocument = new XmlDocument(); var licenseElement = licenseDocument.CreateElement(LicenseElements.License); licenseDocument.AppendChild(licenseElement); var id = licenseDocument.CreateElement(LicenseElements.Id); id.InnerText = licenseCriteria.Id.ToString(); licenseElement.AppendChild(id); var expirationDate = licenseDocument.CreateElement(LicenseElements.ExpirationDate); expirationDate.InnerText = licenseCriteria.ExpirationDate.ToString("o"); licenseElement.AppendChild(expirationDate); var issueDate = licenseDocument.CreateElement(LicenseElements.IssueDate); issueDate.InnerText = licenseCriteria.IssueDate.ToString("o"); licenseElement.AppendChild(issueDate); var type = licenseDocument.CreateElement(LicenseElements.Type); type.InnerText = licenseCriteria.Type; licenseElement.AppendChild(type); foreach (var metaData in licenseCriteria.MetaData) { var element = licenseDocument.CreateElement(metaData.Key); element.InnerText = metaData.Value; licenseElement.AppendChild(element); } return licenseDocument; }
public LicenseCriteria Parse(IClientLicense clientLicense) { var license = XDocument.Parse(clientLicense.Content.OuterXml).Root; if (license == null) { throw new InvalidDataException("Document is invalid. A root node was expected"); } var licenseDetails = license.Elements() .Where(element => element.Name.LocalName != LicenseElements.Signature) .Select(element => new KeyValuePair<string, string>(element.Name.LocalName, element.Value)) .ToDictionary(pair => pair.Key, pair => pair.Value); var licenseCriteria = new LicenseCriteria { ExpirationDate = DateTimeOffset.Parse(licenseDetails[LicenseElements.ExpirationDate]), IssueDate = DateTimeOffset.Parse(licenseDetails[LicenseElements.IssueDate]), Id = Guid.Parse(licenseDetails[LicenseElements.Id]), Type = licenseDetails[LicenseElements.Type] }; licenseDetails.Remove(LicenseElements.ExpirationDate); licenseDetails.Remove(LicenseElements.Id); licenseDetails.Remove(LicenseElements.IssueDate); licenseDetails.Remove(LicenseElements.Type); licenseCriteria.MetaData = licenseDetails; return licenseCriteria; }
public static void Main(string[] args) { var dataDirectory = @"..\..\..\..\LicenseData".ResolveBaseDirectory(); var publicKeyPath = @"..\..\..\..\LicenseData\PublicKey.xml".ResolveBaseDirectory(); var licensePath = @"..\..\..\..\LicenseData\License.xml".ResolveBaseDirectory(); if (!Directory.Exists(dataDirectory)) { Directory.CreateDirectory(dataDirectory); } var licenseCriteria = new LicenseCriteria { ExpirationDate = DateTimeOffset.UtcNow.LastDayOfMonth().EndOfDay(), IssueDate = DateTimeOffset.UtcNow, Id = Guid.NewGuid(), MetaData = new Dictionary<string, string> { { "LicensedCores", "2" } }, Type = "Subscription" }; var privateKey = new RsaPrivateKeyProvider().Create(); var serverLicense = new ServerLicenseGenerator().Generate(privateKey, licenseCriteria); var clientLicense = serverLicense.ToClientLicense(); // In a real implementation, you would embed the public key into the assembly, via a resource file File.WriteAllText(publicKeyPath, privateKey.ExtractPublicKey().Contents); // In a real implementation you would implement ILicenseRepository File.WriteAllText(licensePath, clientLicense.Content.InnerXml); Console.WriteLine(Messsages.LicenseGenerated, dataDirectory); Console.WriteLine(Messsages.PressAnyKey); Console.ReadKey(); }
public void GivenIGenerateTheirLicense() { var subscriptionStartDate = ScenarioContext.Current.Get<DateTimeOffset>(ContextKey.LicenseIssueDate); var licenseType = ScenarioContext.Current.Get<string>(ContextKey.LicenseType); Dictionary<string, string> metadata; if (!ScenarioContext.Current.TryGetValue(ContextKey.LicenseMetadata, out metadata)) { metadata = new Dictionary<string, string>(); } var licenseCriteria = new LicenseCriteria { ExpirationDate = subscriptionStartDate.LastDayOfMonth().EndOfDay(), IssueDate = subscriptionStartDate, Id = Guid.NewGuid(), MetaData = metadata, Type = licenseType }; var privateKey = this.privateKeyProvider.Create(); var serverLicense = this.serverLicenseGenerator.Generate(privateKey, licenseCriteria); var clientLicense = serverLicense.ToClientLicense(); ScenarioContext.Current.Set(serverLicense, ContextKey.ServerLicense); ScenarioContext.Current.Set(privateKey.ExtractPublicKey(), ContextKey.PublicKey); ScenarioContext.Current.Set(clientLicense, ContextKey.ClientLicense); }
/// <summary> /// Validates the supplied client license against the private key and the set of validation rules. Violations are exposed via exceptions or aggregate exceptions. /// </summary> /// <param name="clientLicense">License to validate</param> /// <param name="publicKey">Public Key to validate the license with</param> /// <param name="validationRules">List of validation rules to examine</param> /// <exception cref="InvalidLicenseException">Indicates that the license is invalid / corrupt / empty.</exception> /// <exception cref="LicenseViolationException">Indicates that a license validation rule has been violated.</exception> /// <exception cref="AggregateException">Indicates that one or more license validation rules have been violated.</exception> public void Validate(IClientLicense clientLicense, ICryptoKey publicKey, IEnumerable<ILicenseValidationRule> validationRules) { if (!LicenseSignatureValidator.ValidateSignature(clientLicense, publicKey)) { throw new InvalidLicenseException(clientLicense); } this.LicenseCriteria = this.licenseCriteriaParser.Parse(clientLicense); validationRules.ForEachFailEnd(x => x.Validate(this.LicenseCriteria)); }
public void Validate(LicenseCriteria licenseCriteria) { // TODO: Get from a time server. if (DateTimeOffset.UtcNow > licenseCriteria.ExpirationDate) { string message = string.Format("License expired on {0}", licenseCriteria.ExpirationDate.ToString("O")); throw new LicenseExpiredException(message, DateTimeOffset.UtcNow) { LicenseCriteria = licenseCriteria }; } }
public IServerLicense Generate(IPrivateCryptoKey privateKey, LicenseCriteria licenseCriteria) { var licenseDocument = this.CreateLicenseDocument(licenseCriteria); var signature = LicenseSignatureGenerator.GenerateSignature(licenseDocument, privateKey); licenseDocument.FirstChild.AppendChild(licenseDocument.ImportNode(signature, true)); return new ServerLicense { Content = licenseDocument, Criteria = licenseCriteria, PrivateKey = privateKey, PublicKey = privateKey.ExtractPublicKey() }; }
public void Validate(LicenseCriteria licenseCriteria) { int licensedCores = 0; if (licenseCriteria.MetaData.ContainsKey("LicensedCores")) { licensedCores = Convert.ToInt32(licenseCriteria.MetaData["LicensedCores"]); } if (Environment.ProcessorCount > licensedCores) { string message = string.Format("This license is only valid for {0} cores.", licensedCores); throw new LicensedCoresExceededException(message, Environment.ProcessorCount) { LicenseCriteria = licenseCriteria }; } }