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