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);
}
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 cryptoKeyProvider = new CryptoKeyProvider();
var privateKey = cryptoKeyProvider.GenerateKey();
var publicKey = cryptoKeyProvider.ExtractPublicKey(privateKey);
Console.WriteLine("Public Key:");
Console.WriteLine(publicKey.Contents);
Console.WriteLine();
var licenseCriteria = new LicenseCriteria
{
ExpirationDate = DateTimeOffset.UtcNow.AddDays(30),
IssueDate = DateTimeOffset.UtcNow,
Id = Guid.NewGuid(),
MetaData = new Dictionary <string, string> {
{ "LicensedCores", "2" }
},
Type = "Subscription"
};
var license = new LicenseGenerator().Generate(privateKey, licenseCriteria);
Console.WriteLine(license.Document);
Console.WriteLine();
Console.ReadKey();
}
/// <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, string elementKey = null)
{
if (!LicenseSignatureValidator.ValidateSignature(clientLicense, publicKey))
{
throw new InvalidLicenseException(clientLicense);
}
this.LicenseCriteria = this.licenseCriteriaParser.Parse(clientLicense, elementKey);
validationRules.ForEachFailEnd(x => x.Validate(this.LicenseCriteria));
}
public IServerLicense Generate(IPrivateCryptoKey privateKey, LicenseCriteria licenseCriteria, string elementKey = null)
{
var licenseDocument = this.CreateLicenseDocument(licenseCriteria);
if (!string.IsNullOrEmpty(elementKey))
{
var hashSha256 = new SHA256CryptoServiceProvider();
var keyArray = hashSha256.ComputeHash(Encoding.UTF8.GetBytes(elementKey));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashSha256.Clear();
// Create a new TripleDES key.
var rijndaelkey = Rijndael.Create();
rijndaelkey.Key = keyArray;
try
{
foreach (var metaData in licenseCriteria.MetaData)
{
// Encrypt the metadata element.
Encrypt(licenseDocument, metaData.Key, rijndaelkey);
}
// Display the encrypted XML to the console.
//Console.WriteLine("Encrypted XML:");
//Console.WriteLine();
//Console.WriteLine(licenseDocument.OuterXml);
}
catch (Exception e)
{
Console.WriteLine(e.Message);
}
finally
{
// Clear the TripleDES key.
rijndaelkey.Clear();
}
}
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 LicenseCriteria Parse(IClientLicense clientLicense, string elementKey = null)
{
XElement license;
if (!string.IsNullOrEmpty(elementKey))
{
var hashSha256 = new SHA256CryptoServiceProvider();
var keyArray = hashSha256.ComputeHash(Encoding.UTF8.GetBytes(elementKey));
//Always release the resources and flush data
// of the Cryptographic service provide. Best Practice
hashSha256.Clear();
// Create a new TripleDES key.
var rijndaelkey = Rijndael.Create();
rijndaelkey.Key = keyArray;
var xdoc = clientLicense.Content;
Decrypt(xdoc, rijndaelkey);
license = XDocument.Parse(xdoc.OuterXml).Root;
}
else
{
license = XDocument.Parse(clientLicense.Content.OuterXml).Root;
}
if (license == null)
{
throw new FormatException("Could not parse XML document");
}
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 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 void Validate(LicenseCriteria licenseCriteria)
{
var licensedCores = 0;
if (licenseCriteria.MetaData.ContainsKey("LicensedCores"))
{
licensedCores = Convert.ToInt32(licenseCriteria.MetaData["LicensedCores"]);
}
if (Environment.ProcessorCount > licensedCores)
{
var message = string.Format("This license is only valid for {0} cores.", licensedCores);
throw new LicensedCoresExceededException(message, Environment.ProcessorCount);
}
}
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 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", "16" }
},
Type = "Subscription"
};
var privateKey = new RsaPrivateKeyProvider().Create();
//var serverLicense = new ServerLicenseGenerator().Generate(privateKey, licenseCriteria);
var serverLicense = new ServerLicenseGenerator().Generate(privateKey, licenseCriteria, "This is my password");
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();
}
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);
}
