public void TestInitialization()
{
var file = new SignedLicense("HardwareID", "SerialNumber", DateTime.Now, DateTime.Now + TimeSpan.FromDays(10), null);
AssertDefaultPropertiesAreValid(file);
Assert.AreEqual(0, file.Properties.Count);
}
public void TestInitialization_WithProperties()
{
var file = new SignedLicense("HardwareID", "SerialNumber", DateTime.Now, DateTime.Now + TimeSpan.FromDays(10), CreateProperties());
AssertDefaultPropertiesAreValid(file);
AssertPropertiesAreValid(file);
}
public void TestInitialization_WithProperties_WithColone()
{
var properties = new Dictionary <string, string>();
properties.Add("Pro:p1", "Val1");
properties.Add("Prop2", "Val2");
try
{
var file = new SignedLicense("HardwareID", "SerialNumber", DateTime.Now, DateTime.Now + TimeSpan.FromDays(10), properties);
Assert.Fail("FormatException expected.");
}
catch (FormatException) { }
}
public void TestSignatureValid_GivenInvalidSignature_Fails()
{
var token = LicenseKeyManager.Create(new SimpleTestLicense())
.CreateAndSignLicense(new LicenseSigningParameters());
var newSignature = new byte[2048 / 8];
RandomNumberGenerator.Fill(newSignature);
token = new SignedLicense(token.LicenseData, newSignature);
Assert.False(token.SignatureValid());
}
public void TestSerialization()
{
var license = new SignedLicense(HardwareIdentifier.NoHardwareIdentifier, "SerialNumber", DateTime.Now, DateTime.Now + TimeSpan.FromDays(10), CreateProperties());
license.Sign(new LengthSigner());
var licPlainText = license.SerializeAsPlainText();
var licEncrypted = license.Serialize();
var licensePlainText = SignedLicense.Deserialize(licPlainText);
var licenseEncrypted = SignedLicense.Deserialize(licEncrypted);
Assert.AreEqual(licensePlainText.SerializeAsPlainText(), licenseEncrypted.SerializeAsPlainText());
Assert.AreEqual(licensePlainText.Serialize(), licenseEncrypted.Serialize());
}
public void Test_GenerateAndReadLicense_BadSigningParameters_Fails()
{
using var originalParameters = new LicenseSigningParameters();
var license = LicenseKeyManager.Create(new SimpleTestLicense())
.CreateAndSignLicense(originalParameters);
using var newParameters = new LicenseSigningParameters();
license = new SignedLicense(license.LicenseData, newParameters.PublicKey);
Assert.Throws <InvalidOperationException>(
() => LicenseKeyManager.Load <SimpleTestLicense>(license)
.Validate());
}
internal string VerifyLicense(string licenseText)
{
var errorMessage = string.Empty;
try
{
SignedLicense license = Lic.Verifier
.WithRsaPublicKey(PublicKey) // .WithSigner(ISigner)
.WithApplicationCode(APP_CODE) // .WithoutApplicationCode
.LoadAndVerify(licenseText);
if (DateTime.Compare(license.ExpirationDate, DateTime.Now) < 0)
{
errorMessage = "License expired";
}
else
{
if ((license.HardwareIdentifier != HardwareIdentifier) ||
(license.Properties["ZId"] != ZId) ||
(license.Properties["ExpirationDate"] != license.ExpirationDate.ToString(DATE_FROMAT)))
{
errorMessage = "Invalid license";
}
if (!HWId.IsCheckSumValid(license.HardwareIdentifier))
{
errorMessage = "Invalid license";
}
}
SupportedApps = license.Properties["SupportedApps"];
SupportedDevices = license.Properties["SupportedDevices"];
}
catch (Exception ex)
{
if (ex.Message.StartsWith("License has been expired"))
{
errorMessage = ex.Message;
}
else
{
errorMessage = "Invalid license";
}
}
return(errorMessage);
}
public void TestSigning_WithProperties_DifferentCultures()
{
var cultureDE = new CultureInfo("de");
var cultureEN = new CultureInfo("en");
Thread.CurrentThread.CurrentCulture = cultureDE;
var file = new SignedLicense("HardwareID", "SerialNumber", DateTime.Now, DateTime.Now + TimeSpan.FromDays(10), CreateProperties());
file.Sign(new HashCodeSigner());
var content = file.Serialize();
Thread.CurrentThread.CurrentCulture = cultureEN;
var newFile = SignedLicense.Deserialize(content);
newFile.Verify(new HashCodeSigner());
}
public void TestSigning_WithProperties()
{
var file = new SignedLicense("HardwareID", "SerialNumber", DateTime.Now, DateTime.Now + TimeSpan.FromDays(10), CreateProperties());
file.Sign(new LengthSigner());
var content = file.Serialize();
var newFile = SignedLicense.Deserialize(content);
AssertDefaultPropertiesAreValid(newFile);
AssertPropertiesAreValid(file);
newFile.Verify(new LengthSigner());
try
{
newFile.Verify(new DoubleLengthSigner());
Assert.Fail("LicenseException expected");
}
catch (SignedLicenseException) { }
}
/// <summary>
/// Сохраняет лицензию в файл, генерирует его подпись и сохраняет подпись в файл по тому же пути и имени но с отличным расширением.
/// </summary>
/// <param name="license">Лицензия</param>
/// <param name="licensePath">Полный путь для сохранения лицензии.</param>
/// <exception cref="InvalidOperationException">Возникает когда не найден закрытый ключ для подписания лицензий.</exception>
internal void SingAndSaveLicense(License license, string licensePath)
{
if (!SecretKeyLoaded)
{
throw new InvalidOperationException("Ошибка генерации лицензии: отсутствует закрытый ключ.");
}
using (var stream = new FileStream(licensePath, FileMode.CreateNew))
{
var signedLicense = new SignedLicense();
signedLicense.License = license;
var mstream = new MemoryStream();
var formatter = new XmlSerializer(license.GetType());
formatter.Serialize(mstream, license);
mstream.Position = 0;
signedLicense.Sign = cryptoProvider.SignData(mstream, new SHA512CryptoServiceProvider());
formatter = new XmlSerializer(signedLicense.GetType());
formatter.Serialize(stream, signedLicense);
}
}
private static void AssertPropertiesAreValid(SignedLicense file)
{
Assert.AreEqual(2, file.Properties.Count);
Assert.AreEqual("Val1", file.Properties["Prop1"]);
Assert.AreEqual("Val2", file.Properties["Prop2"]);
}
private static void AssertDefaultPropertiesAreValid(SignedLicense file)
{
Assert.AreEqual("HardwareID", file.HardwareIdentifier);
Assert.AreEqual(DateTime.UtcNow.Date, file.IssueDate);
Assert.AreEqual("SerialNumber", file.SerialNumber);
}
public StandardLicenseValidator(SignedLicense license) => _licenseKey =
