// Serialize a license key to a stream.
public static void Serialize(Stream o, String cryptoKey,
DesigntimeLicenseContext context)
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize
(o, new Object [] {cryptoKey, context.keys});
}
private static void SerializeWithBinaryFormatter(Stream o, string cryptoKey, DesigntimeLicenseContext context)
{
IFormatter formatter = new BinaryFormatter();
#pragma warning disable SYSLIB0011
formatter.Serialize(o, new object[] { cryptoKey, context._savedLicenseKeys });
#pragma warning restore SYSLIB0011
}
/// <summary>
/// Serializes the licenses within the specified design-time license context
/// using the specified key and output stream.
/// </summary>
public static void Serialize(Stream o, string cryptoKey, DesigntimeLicenseContext context)
{
IFormatter formatter = new BinaryFormatter();
#pragma warning disable SYSLIB0011 // Issue https://github.com/dotnet/runtime/issues/39293 tracks finding an alternative to BinaryFormatter
formatter.Serialize(o, new object[] { cryptoKey, context._savedLicenseKeys });
#pragma warning restore SYSLIB0011
}
// Serialize a license key to a stream.
public static void Serialize(Stream o, String cryptoKey,
DesigntimeLicenseContext context)
{
BinaryFormatter formatter = new BinaryFormatter();
formatter.Serialize
(o, new Object [] { cryptoKey, context.keys });
}
private static void SerializeWithBinaryFormatter(Stream o, string cryptoKey, DesigntimeLicenseContext context)
{
IFormatter formatter = new BinaryFormatter();
#pragma warning disable SYSLIB0011
#pragma warning disable IL2026 // suppressed in ILLink.Suppressions.LibraryBuild.xml
formatter.Serialize(o, new object[] { cryptoKey, context._savedLicenseKeys });
#pragma warning restore IL2026
#pragma warning restore SYSLIB0011
}
public static void Serialize (Stream o, string cryptoKey, DesigntimeLicenseContext context)
{
object [] lData = new object [2];
lData [0] = cryptoKey;
Hashtable lNewTable = new Hashtable ();
foreach (DictionaryEntry et in context.keys) {
lNewTable.Add (((Type) et.Key).AssemblyQualifiedName, et.Value);
}
lData[1] = lNewTable;
BinaryFormatter lFormatter = new BinaryFormatter ();
lFormatter.Serialize (o, lData);
}
public static void Serialize(Stream o, string cryptoKey, DesigntimeLicenseContext context)
{
object [] lData = new object [2];
lData [0] = cryptoKey;
Hashtable lNewTable = new Hashtable();
foreach (DictionaryEntry et in context.keys)
{
lNewTable.Add(((Type)et.Key).AssemblyQualifiedName, et.Value);
}
lData[1] = lNewTable;
BinaryFormatter lFormatter = new BinaryFormatter();
lFormatter.Serialize(o, lData);
}
/// <summary>
/// Serializes the licenses within the specified design-time license context
/// using the specified key and output stream.
/// </summary>
public static void Serialize(Stream o, string cryptoKey, DesigntimeLicenseContext context)
{
if (EnableUnsafeBinaryFormatterInDesigntimeLicenseContextSerialization)
{
SerializeWithBinaryFormatter(o, cryptoKey, context);
}
else
{
using (BinaryWriter writer = new BinaryWriter(o, encoding: Text.Encoding.UTF8, leaveOpen: true))
{
writer.Write(BinaryWriterMagic); // flag to identify BinaryWriter
writer.Write(cryptoKey);
writer.Write(context._savedLicenseKeys.Count);
foreach (DictionaryEntry keyAndValue in context._savedLicenseKeys)
{
writer.Write(keyAndValue.Key.ToString() !);
writer.Write(keyAndValue.Value !.ToString() !);
}
}
}
}
// The CLR invokes this whenever a COM client invokes
// IClassFactory2::GetLicInfo on a managed class.
//
// COM normally doesn't expect this function to fail so this method
// should only throw in the case of a catastrophic error (stack, memory, etc.)
private void GetLicInfo(RuntimeTypeHandle rth, ref int pRuntimeKeyAvail, ref int pLicVerified) {
pRuntimeKeyAvail = 0;
pLicVerified = 0;
Type type = Type.GetTypeFromHandle(rth);
License license;
string licenseKey;
if (helperContext == null) {
helperContext = new DesigntimeLicenseContext();
}
else {
helperContext.savedLicenseKeys.Clear();
}
if (LicenseManager.ValidateInternalRecursive(helperContext, type, null, false, out license, out licenseKey)) {
if (helperContext.savedLicenseKeys.Contains(type.AssemblyQualifiedName)) {
pRuntimeKeyAvail = 1;
}
if (license != null) {
license.Dispose();
license = null;
pLicVerified = 1;
}
}
}
/// <summary>
/// Creates the whole license file.
/// </summary>
/// <param name="licenseTask">The <see cref="LicenseTask" /> instance for which the license file should be created.</param>
/// <param name="licensesFile">The .licenses file to create.</param>
public void CreateLicenseFile(LicenseTask licenseTask, string licensesFile) {
ArrayList assemblies = new ArrayList();
// create assembly resolver
AssemblyResolver assemblyResolver = new AssemblyResolver(licenseTask);
// attach assembly resolver to the current domain
assemblyResolver.Attach();
licenseTask.Log(Level.Verbose, ResourceUtils.GetString("String_LoadingAssemblies"));
try {
// first, load all the assemblies so that we can search for the
// licensed component
foreach (string assemblyFileName in licenseTask.Assemblies.FileNames) {
Assembly assembly = Assembly.LoadFrom(assemblyFileName);
if (assembly != null) {
// output assembly filename to build log
licenseTask.Log(Level.Verbose, ResourceUtils.GetString("String_AssemblyLoaded"),
assemblyFileName);
// add assembly to list of loaded assemblies
assemblies.Add(assembly);
}
}
DesigntimeLicenseContext dlc = new DesigntimeLicenseContext();
LicenseManager.CurrentContext = dlc;
// read the input file
using (StreamReader sr = new StreamReader(licenseTask.InputFile.FullName)) {
Hashtable licenseTypes = new Hashtable();
licenseTask.Log(Level.Verbose, ResourceUtils.GetString("String_CreatingLicenses"));
while (true) {
string line = sr.ReadLine();
if (line == null) {
break;
}
line = line.Trim();
// Skip comments, empty lines and already processed assemblies
if (line.StartsWith("#") || line.Length == 0 || licenseTypes.Contains(line)) {
continue;
}
licenseTask.Log(Level.Verbose, "{0}: ", line);
// Strip off the assembly name, if it exists
string typeName;
if (line.IndexOf(',') != -1) {
typeName = line.Split(',')[0];
} else {
typeName = line;
}
Type tp = null;
// try to locate the type in each assembly
foreach (Assembly assembly in assemblies) {
if (tp == null) {
tp = assembly.GetType(typeName, false, true);
}
if (tp != null) {
break;
}
}
if (tp == null) {
try {
// final attempt, assuming line contains
// assembly qualfied name
tp = Type.GetType(line, false, false);
} catch {
// ignore error, we'll report the load
// failure later
}
}
if (tp == null) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2016"), typeName), licenseTask.Location);
} else {
// add license type to list of processed license types
licenseTypes[line] = tp;
}
// ensure that we've got a licensed component
if (tp.GetCustomAttributes(typeof(LicenseProviderAttribute), true).Length == 0) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2017"), tp.FullName),
licenseTask.Location);
}
try {
LicenseManager.CreateWithContext(tp, dlc);
} catch (Exception ex) {
if (IsSerializable(ex)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2018"), tp.FullName),
licenseTask.Location, ex);
}
// do not directly pass the exception as inner
// exception to BuildException as the exception
// is not serializable, so construct a new
// exception with message set to message of
// original exception
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2018"), tp.FullName),
licenseTask.Location, new Exception(ex.Message));
}
}
}
// overwrite the existing file, if it exists - is there a better way?
if (File.Exists(licensesFile)) {
File.SetAttributes(licensesFile, FileAttributes.Normal);
File.Delete(licensesFile);
}
// write out the license file, keyed to the appropriate output
// target filename
// this .license file will only be valid for this exe/dll
using (FileStream fs = new FileStream(licensesFile, FileMode.Create)) {
DesigntimeLicenseContextSerializer.Serialize(fs, licenseTask.Target, dlc);
licenseTask.Log(Level.Verbose, ResourceUtils.GetString("String_CreatedNewLicense"),
licensesFile);
}
dlc = null;
} catch (BuildException) {
// re-throw exception
throw;
} catch (Exception ex) {
if (IsSerializable(ex)) {
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2019"), licenseTask.InputFile.FullName),
licenseTask.Location, ex);
} else {
// do not directly pass the exception as inner exception to
// BuildException as the exception might not be serializable,
// so construct a
// new exception with message set to message of
// original exception
throw new BuildException(string.Format(CultureInfo.InvariantCulture,
ResourceUtils.GetString("NA2019"), licenseTask.InputFile.FullName),
licenseTask.Location, new Exception(ex.Message));
}
} finally {
// detach assembly resolver from the current domain
assemblyResolver.Detach();
}
}
public void Test()
{
object lockObject = new object();
//**DEFAULT CONTEXT & LicenseUsageMode**
//Get CurrentContext, check default type
Assert.Equal("System.ComponentModel.Design.RuntimeLicenseContext", LicenseManager.CurrentContext.GetType().ToString());
//Read default LicenseUsageMode, check against CurrentContext (LicCont).UsageMode
Assert.Equal(LicenseManager.CurrentContext.UsageMode, LicenseManager.UsageMode);
//**CHANGING CONTEXT**
//Change the context and check it changes
LicenseContext oldcontext = LicenseManager.CurrentContext;
LicenseContext newcontext = new DesigntimeLicenseContext();
LicenseManager.CurrentContext = newcontext;
Assert.Equal(newcontext, LicenseManager.CurrentContext);
//Check the UsageMode changed too
Assert.Equal(newcontext.UsageMode, LicenseManager.UsageMode);
//Set Context back to original
LicenseManager.CurrentContext = oldcontext;
//Check it went back
Assert.Equal(oldcontext, LicenseManager.CurrentContext);
//Check the UsageMode changed too
Assert.Equal(oldcontext.UsageMode, LicenseManager.UsageMode);
//**CONTEXT LOCKING**
//Lock the context
LicenseManager.LockContext(lockObject);
//Try and set new context again, should throw System.InvalidOperationException: The CurrentContext property of the LicenseManager is currently locked and cannot be changed.
bool exceptionThrown = false;
try
{
LicenseManager.CurrentContext = newcontext;
}
catch (Exception e)
{
Assert.Equal(typeof(InvalidOperationException), e.GetType());
exceptionThrown = true;
}
//Check the exception was thrown
Assert.Equal(true, exceptionThrown);
//Check the context didn't change
Assert.Equal(oldcontext, LicenseManager.CurrentContext);
//Unlock it
LicenseManager.UnlockContext(lockObject);
//Now's unlocked, change it
LicenseManager.CurrentContext = newcontext;
Assert.Equal(newcontext, LicenseManager.CurrentContext);
//Change it back
LicenseManager.CurrentContext = oldcontext;
//Lock the context
LicenseManager.LockContext(lockObject);
//Unlock with different "user" should throw System.ArgumentException: The CurrentContext property of the LicenseManager can only be unlocked with the same contextUser.
object wrongLockObject = new object();
exceptionThrown = false;
try
{
LicenseManager.UnlockContext(wrongLockObject);
}
catch (Exception e)
{
Assert.Equal(typeof(ArgumentException), e.GetType());
exceptionThrown = true;
}
Assert.Equal(true, exceptionThrown);
//Unlock it
LicenseManager.UnlockContext(lockObject);
//** bool IsValid(Type);
Assert.Equal(true, LicenseManager.IsLicensed(typeof(UnlicensedObject)));
Assert.Equal(true, LicenseManager.IsLicensed(typeof(LicensedObject)));
Assert.Equal(false, LicenseManager.IsLicensed(typeof(InvalidLicensedObject)));
Assert.Equal(true, LicenseManager.IsValid(typeof(UnlicensedObject)));
Assert.Equal(true, LicenseManager.IsValid(typeof(LicensedObject)));
Assert.Equal(false, LicenseManager.IsValid(typeof(InvalidLicensedObject)));
UnlicensedObject unlicensedObject = new UnlicensedObject();
LicensedObject licensedObject = new LicensedObject();
InvalidLicensedObject invalidLicensedObject = new InvalidLicensedObject();
//** bool IsValid(Type, object, License);
License license = null;
Assert.Equal(true, LicenseManager.IsValid(unlicensedObject.GetType(), unlicensedObject, out license));
Assert.Equal(null, license);
license = null;
Assert.Equal(true, LicenseManager.IsValid(licensedObject.GetType(), licensedObject, out license));
Assert.Equal("TestLicense", license.GetType().Name);
license = null;
Assert.Equal(false, LicenseManager.IsValid(invalidLicensedObject.GetType(), invalidLicensedObject, out license));
Assert.Equal(null, license);
//** void Validate(Type);
//Shouldn't throw exception
LicenseManager.Validate(typeof(UnlicensedObject));
//Shouldn't throw exception
LicenseManager.Validate(typeof(LicensedObject));
//Should throw exception
exceptionThrown = false;
try
{
LicenseManager.Validate(typeof(InvalidLicensedObject));
}
catch (Exception e)
{
Assert.Equal(typeof(LicenseException), e.GetType());
exceptionThrown = true;
}
//Check the exception was thrown
Assert.Equal(true, exceptionThrown);
//** License Validate(Type, object);
//Shouldn't throw exception, returns null license
license = LicenseManager.Validate(typeof(UnlicensedObject), unlicensedObject);
Assert.Equal(null, license);
//Shouldn't throw exception, returns TestLicense license
license = LicenseManager.Validate(typeof(LicensedObject), licensedObject);
Assert.Equal("TestLicense", license.GetType().Name);
//Should throw exception, returns null license
exceptionThrown = false;
try
{
license = null;
license = LicenseManager.Validate(typeof(InvalidLicensedObject), invalidLicensedObject);
}
catch (Exception e)
{
Assert.Equal(typeof(LicenseException), e.GetType());
exceptionThrown = true;
}
//Check the exception was thrown
Assert.Equal(true, exceptionThrown);
Assert.Equal(null, license);
//** object CreateWithContext (Type, LicenseContext);
object cwc = null;
//Test we can create an unlicensed object with no context
cwc = LicenseManager.CreateWithContext(typeof(UnlicensedObject), null);
Assert.Equal("UnlicensedObject", cwc.GetType().Name);
//Test we can create RunTime with CurrentContext (runtime)
cwc = null;
cwc = LicenseManager.CreateWithContext(typeof(RuntimeLicensedObject),
LicenseManager.CurrentContext);
Assert.Equal("RuntimeLicensedObject", cwc.GetType().Name);
//Test we can't create DesignTime with CurrentContext (runtime)
exceptionThrown = false;
try
{
cwc = null;
cwc = LicenseManager.CreateWithContext(typeof(DesigntimeLicensedObject), LicenseManager.CurrentContext);
}
catch (Exception e)
{
Assert.Equal(typeof(LicenseException), e.GetType());
exceptionThrown = true;
}
//Check the exception was thrown
Assert.Equal(true, exceptionThrown);
//Test we can create DesignTime with A new DesignTimeContext
cwc = null;
cwc = LicenseManager.CreateWithContext(typeof(DesigntimeLicensedObject),
new DesigntimeLicenseContext());
Assert.Equal("DesigntimeLicensedObject", cwc.GetType().Name);
//** object CreateWithContext(Type, LicenseContext, object[]);
//Test we can create RunTime with CurrentContext (runtime)
cwc = null;
cwc = LicenseManager.CreateWithContext(typeof(RuntimeLicensedObject),
LicenseManager.CurrentContext, new object[] { 7 });
Assert.Equal("RuntimeLicensedObject", cwc.GetType().Name);
}
public static void Serialize(Stream o,
string cryptoKey,
DesigntimeLicenseContext context)
{
throw new NotImplementedException();
}
private static void IntSerialize(Stream o,
string cryptoKey,
DesigntimeLicenseContext context)
{
Object[] lData = new Object[2];
lData[0] = cryptoKey;
Hashtable lNewTable = new Hashtable();
FieldInfo fi =
typeof(DesigntimeLicenseContext).GetField("savedLicenseKeys", BindingFlags.NonPublic | BindingFlags.Instance) ??
typeof(DesigntimeLicenseContext).GetField("keys", BindingFlags.NonPublic | BindingFlags.Instance)
;
Hashtable lOrgTable = (Hashtable)fi.GetValue(context);
foreach (DictionaryEntry et in lOrgTable)
{
if (et.Key is string)
lNewTable.Add(et.Key, et.Value);
else
lNewTable.Add(((Type)et.Key).AssemblyQualifiedName, et.Value);
}
lData[1] = lNewTable;
BinaryFormatter lFormatter = new BinaryFormatter();
lFormatter.Serialize(o, lData);
}
public static void Serialize(Stream o, string cryptoKey, DesigntimeLicenseContext context)
{
Contract.Requires(context != null);
}
public static void Serialize(Stream o, string cryptoKey, DesigntimeLicenseContext context)
{
Contract.Requires(context != null);
}