public override License GetLicense (LicenseContext context,
Type type,
object instance,
bool allowExceptions)
{
if (type.Name.Equals ("RuntimeLicensedObject")) {
if (context.UsageMode != LicenseUsageMode.Runtime)
if (allowExceptions)
throw new LicenseException (type, instance, "License fails because this is a Runtime only license");
else
return null;
return new TestLicense ();
}
if (type.Name.Equals ("DesigntimeLicensedObject"))
{
if (context.UsageMode != LicenseUsageMode.Designtime)
if (allowExceptions)
throw new LicenseException (type, instance, "License fails because this is a Designtime only license");
else
return null;
return new TestLicense ();
}
if (type.Name.Equals ("LicensedObject"))
return new TestLicense ();
if (allowExceptions)
throw new LicenseException (type, instance, "License fails because of class name.");
else
return null;
}
/// <summary>
/// Creates an instance of the specified type with the
/// specified arguments, using creationContext as the context in which the licensed
/// instance can be used.
/// </summary>
public static object CreateWithContext(Type type, LicenseContext creationContext, object[] args)
{
object created = null;
lock (s_internalSyncObject)
{
LicenseContext normal = CurrentContext;
try
{
CurrentContext = creationContext;
LockContext(s_selfLock);
try
{
created = Activator.CreateInstance(type, args);
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
}
finally
{
UnlockContext(s_selfLock);
CurrentContext = normal;
}
}
return(created);
}
public static object CreateWithContext(Type type, LicenseContext creationContext, object[] args)
{
object obj2 = null;
lock (internalSyncObject)
{
LicenseContext currentContext = CurrentContext;
try
{
CurrentContext = creationContext;
LockContext(selfLock);
try
{
obj2 = SecurityUtils.SecureCreateInstance(type, args);
}
catch (TargetInvocationException exception)
{
throw exception.InnerException;
}
return obj2;
}
finally
{
UnlockContext(selfLock);
CurrentContext = currentContext;
}
}
return obj2;
}
public override License GetLicense (LicenseContext context,
Type type,
object instance,
bool allowExceptions)
{
try
{
if (context == null || context.UsageMode != LicenseUsageMode.Designtime)
return null;
string path = Path.GetDirectoryName (type.Assembly.Location);
path = Path.Combine (path, type.FullName + ".LIC");
if (!File.Exists (path)) return null;
StreamReader sr = new StreamReader (path);
string key = sr.ReadLine ();
sr.Close ();
if (IsKeyValid (key, type))
return new LicFileLicense (key);
}
catch
{
if (allowExceptions) throw;
}
return null;
}
/// <include file='doc\LicenseManager.uex' path='docs/doc[@for="LicenseManager.CreateWithContext1"]/*' />
/// <devdoc>
/// <para>Creates an instance of the specified type with the
/// specified arguments, using creationContext as the context in which the licensed
/// instance can be used.</para>
/// </devdoc>
public static object CreateWithContext(Type type, LicenseContext creationContext, object[] args)
{
if ((!(type.IsPublic || type.IsNestedPublic)) && (type.Assembly == typeof(LicenseManager).Assembly))
{
IntSecurity.FullReflection.Demand();
}
object created = null;
lock (typeof(LicenseManager)) {
LicenseContext normal = CurrentContext;
try {
CurrentContext = creationContext;
LockContext(selfLock);
try {
created = Activator.CreateInstance(type, BindingFlags.Instance | BindingFlags.Public | BindingFlags.CreateInstance, null, args, null);
}
catch (TargetInvocationException e) {
throw e.InnerException;
}
}
finally {
UnlockContext(selfLock);
CurrentContext = normal;
}
}
return(created);
}
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
ScutexLicense license = null;
try
{
if (context.UsageMode == LicenseUsageMode.Designtime)
{
if (_licensingManager != null)
license = _licensingManager.Validate(InteractionModes.Silent);
if (license != null)
{
if (!license.IsLicenseValid())
{
//throw new LicenseException(type, instance, "Invalid license or trial expired");
return null;
}
else
{
return new ScutexComponentLicense(license);
}
}
}
return null;
}
catch (Exception ex)
{
return null;
}
}
public static object?CreateWithContext(
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type,
LicenseContext creationContext,
object[] args)
{
object?created = null;
lock (s_internalSyncObject)
{
LicenseContext normal = CurrentContext;
try
{
CurrentContext = creationContext;
LockContext(s_selfLock);
try
{
created = Activator.CreateInstance(type, args);
}
catch (TargetInvocationException e)
{
throw e.InnerException !;
}
}
finally
{
UnlockContext(s_selfLock);
CurrentContext = normal;
}
}
return(created);
}
public static object CreateWithContext(Type type, LicenseContext creationContext, object[] args)
{
object obj2 = null;
lock (internalSyncObject)
{
LicenseContext currentContext = CurrentContext;
try
{
CurrentContext = creationContext;
LockContext(selfLock);
try
{
obj2 = SecurityUtils.SecureCreateInstance(type, args);
}
catch (TargetInvocationException exception)
{
throw exception.InnerException;
}
return(obj2);
}
finally
{
UnlockContext(selfLock);
CurrentContext = currentContext;
}
}
return(obj2);
}
/// <summary>Creates an instance of the specified type with the specified arguments, given a context in which you can use the licensed instance.</summary>
/// <returns>An instance of the specified type with the given array of arguments.</returns>
/// <param name="type">A <see cref="T:System.Type" /> that represents the type to create. </param>
/// <param name="creationContext">A <see cref="T:System.ComponentModel.LicenseContext" /> that specifies when you can use the licensed instance. </param>
/// <param name="args">An array of type <see cref="T:System.Object" /> that represents the arguments for the type. </param>
public static object CreateWithContext(Type type, LicenseContext creationContext, object[] args)
{
object result = null;
object obj = LicenseManager.lockObject;
lock (obj)
{
object contextUser = new object();
LicenseContext currentContext = LicenseManager.CurrentContext;
LicenseManager.CurrentContext = creationContext;
LicenseManager.LockContext(contextUser);
try
{
result = Activator.CreateInstance(type, args);
}
catch (TargetInvocationException ex)
{
throw ex.InnerException;
}
finally
{
LicenseManager.UnlockContext(contextUser);
LicenseManager.CurrentContext = currentContext;
}
}
return(result);
}
/// <summary>Returns a license for the instance of the component, if one is available.</summary>
/// <returns>A valid <see cref="T:System.ComponentModel.License" />. If this method cannot find a valid <see cref="T:System.ComponentModel.License" /> or a valid <paramref name="context" /> parameter, it returns null.</returns>
/// <param name="context">A <see cref="T:System.ComponentModel.LicenseContext" /> that specifies where you can use the licensed object. </param>
/// <param name="type">A <see cref="T:System.Type" /> that represents the component requesting the <see cref="T:System.ComponentModel.License" />. </param>
/// <param name="instance">An object that requests the <see cref="T:System.ComponentModel.License" />. </param>
/// <param name="allowExceptions">true if a <see cref="T:System.ComponentModel.LicenseException" /> should be thrown when a component cannot be granted a license; otherwise, false. </param>
/// <PermissionSet>
/// <IPermission class="System.Security.Permissions.FileIOPermission, mscorlib, Version=2.0.3600.0, Culture=neutral, PublicKeyToken=b77a5c561934e089" version="1" Unrestricted="true" />
/// </PermissionSet>
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
try
{
if (context == null || context.UsageMode != LicenseUsageMode.Designtime)
{
return(null);
}
string directoryName = Path.GetDirectoryName(type.Assembly.Location);
directoryName = Path.Combine(directoryName, type.FullName + ".LIC");
if (!File.Exists(directoryName))
{
return(null);
}
StreamReader streamReader = new StreamReader(directoryName);
string key = streamReader.ReadLine();
streamReader.Close();
if (IsKeyValid(key, type))
{
return(new LicFileLicense(key));
}
}
catch
{
if (allowExceptions)
{
throw;
}
}
return(null);
}
/// <summary>
/// <para>Gets a license for the instance of the component and determines if it is valid.</para>
/// </summary>
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
LicFileLicense lic = null;
Debug.Assert(context != null, "No context provided!");
if (context != null)
{
if (context.UsageMode == LicenseUsageMode.Runtime)
{
string key = context.GetSavedLicenseKey(type, null);
if (key != null && IsKeyValid(key, type))
{
lic = new LicFileLicense(this, key);
}
}
if (lic == null)
{
string modulePath = null;
if (context != null)
{
ITypeResolutionService resolver = (ITypeResolutionService)context.GetService(typeof(ITypeResolutionService));
if (resolver != null)
{
modulePath = resolver.GetPathOfAssembly(type.Assembly.GetName());
}
}
if (modulePath == null)
{
modulePath = type.Module.FullyQualifiedName;
}
string moduleDir = Path.GetDirectoryName(modulePath);
string licenseFile = moduleDir + "\\" + type.FullName + ".lic";
Debug.WriteLine($"Looking for license in: {licenseFile}");
if (File.Exists(licenseFile))
{
Stream licStream = new FileStream(licenseFile, FileMode.Open, FileAccess.Read, FileShare.Read);
StreamReader sr = new StreamReader(licStream);
string s = sr.ReadLine();
sr.Close();
if (IsKeyValid(s, type))
{
lic = new LicFileLicense(this, GetKey(type));
}
}
if (lic != null)
{
context.SetSavedLicenseKey(type, lic.LicenseKey);
}
}
}
return(lic);
}
/// <summary>
/// <para>Gets a license for the instance of the component and determines if it is valid.</para>
/// </summary>
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
LicFileLicense lic = null;
Debug.Assert(context != null, "No context provided!");
if (context != null)
{
if (context.UsageMode == LicenseUsageMode.Runtime)
{
string key = context.GetSavedLicenseKey(type, null);
if (key != null && IsKeyValid(key, type))
{
lic = new LicFileLicense(this, key);
}
}
if (lic == null)
{
string modulePath = null;
if (context != null)
{
ITypeResolutionService resolver = (ITypeResolutionService)context.GetService(typeof(ITypeResolutionService));
if (resolver != null)
{
modulePath = resolver.GetPathOfAssembly(type.Assembly.GetName());
}
}
if (modulePath == null)
{
modulePath = type.Module.FullyQualifiedName;
}
string moduleDir = Path.GetDirectoryName(modulePath);
string licenseFile = moduleDir + "\\" + type.FullName + ".lic";
Debug.WriteLine($"Looking for license in: {licenseFile}");
if (File.Exists(licenseFile))
{
Stream licStream = new FileStream(licenseFile, FileMode.Open, FileAccess.Read, FileShare.Read);
StreamReader sr = new StreamReader(licStream);
string s = sr.ReadLine();
sr.Close();
if (IsKeyValid(s, type))
{
lic = new LicFileLicense(this, GetKey(type));
}
}
if (lic != null)
{
context.SetSavedLicenseKey(type, lic.LicenseKey);
}
}
}
return lic;
}
private static bool ValidateInternalRecursive(LicenseContext context, Type type, object instance, bool allowExceptions, out License license, out string licenseKey)
{
LicenseProvider cachedProvider = GetCachedProvider(type);
if ((cachedProvider == null) && !GetCachedNoLicenseProvider(type))
{
LicenseProviderAttribute attribute = (LicenseProviderAttribute)Attribute.GetCustomAttribute(type, typeof(LicenseProviderAttribute), false);
if (attribute != null)
{
Type licenseProvider = attribute.LicenseProvider;
cachedProvider = GetCachedProviderInstance(licenseProvider);
if (cachedProvider == null)
{
cachedProvider = (LicenseProvider)SecurityUtils.SecureCreateInstance(licenseProvider);
}
}
CacheProvider(type, cachedProvider);
}
license = null;
bool flag = true;
licenseKey = null;
if (cachedProvider != null)
{
license = cachedProvider.GetLicense(context, type, instance, allowExceptions);
if (license == null)
{
flag = false;
}
else
{
licenseKey = license.LicenseKey;
}
}
if (flag && (instance == null))
{
string str;
Type baseType = type.BaseType;
if (!(baseType != typeof(object)) || (baseType == null))
{
return(flag);
}
if (license != null)
{
license.Dispose();
license = null;
}
flag = ValidateInternalRecursive(context, baseType, null, allowExceptions, out license, out str);
if (license != null)
{
license.Dispose();
license = null;
}
}
return(flag);
}
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
FileLicense license = null;
StringBuilder listMsg = new StringBuilder();
if (context != null)
{
if (context.UsageMode == LicenseUsageMode.Designtime)
{
license = new FileLicense(this, "");
}
if (license != null)
{
return license;
}
//licenses
string licenseFile = GetlicFilePath();
if (!string.IsNullOrWhiteSpace(licenseFile) && File.Exists(licenseFile))
{
try
{
StreamReader sr = new StreamReader(licenseFile, Encoding.Default);
String xmlStr = DESEncrypt.Decrypt(sr.ReadToEnd());
var entity = XmlFormatterSerializer.DeserializeFromXml<LicenseEntity>(xmlStr, typeof(LicenseEntity));
if (entity != null)
{
var pastDate = DateTime.Parse(entity.PastDate);
if (DateTime.Now > pastDate)
{
listMsg.AppendLine(" 许可证已过期");
}
}
if (listMsg.Length > 5)
{
listMsg.Insert(0, " 许可证编号:" + entity.ID);
listMsg.Insert(1, " 许可证名称:" + entity.Name);
listMsg.Insert(2, " 程序集版本号:" + entity.AssemblyName);
license = new FileLicense(this, listMsg.ToString());
}
else
license = new FileLicense(this, "");
}
catch (IOException e)
{
license = new FileLicense(this, "检查许可证失败" + e.Message);
}
}
else
{
license = new FileLicense(this, "lic文件不存在,请联系供应商");
}
}
return license;
}
public override System.ComponentModel.License GetLicense( LicenseContext context,
Type type,
object instance,
bool allowExceptions)
{
/* the context passed in can be used to determine runtime or designtime usage, however it does not handle
* saved license keys and therfore we have our own to handle that.
* There is a resource drain if the requesting controls do not release the License generated and returned
* to them.
*/
XEditNetLicenseContext lcTemp = new XEditNetLicenseContext();
return new XEditNetLicence(lcTemp.GetSavedLicenseKey(typeof(XEditNetLicenseProvider),System.Reflection.Assembly.GetExecutingAssembly()));
}
// The CLR invokes this when instantiating an unmanaged COM
// object. The purpose is to decide which IClassFactory method to
// use.
public static LicenseContext GetCurrentContextInfo(Type type, out bool isDesignTime, out string key)
{
LicenseContext licContext = LicenseManager.CurrentContext;
isDesignTime = licContext.UsageMode == LicenseUsageMode.Designtime;
key = null;
if (!isDesignTime)
{
key = licContext.GetSavedLicenseKey(type, resourceAssembly: null);
}
return(licContext);
}
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
LicFileLicense license = null;
if (context != null)
{
if (context.UsageMode == LicenseUsageMode.Runtime)
{
string savedLicenseKey = context.GetSavedLicenseKey(type, null);
if ((savedLicenseKey != null) && this.IsKeyValid(savedLicenseKey, type))
{
license = new LicFileLicense(this, savedLicenseKey);
}
}
if (license != null)
{
return(license);
}
string path = null;
if (context != null)
{
ITypeResolutionService service = (ITypeResolutionService)context.GetService(typeof(ITypeResolutionService));
if (service != null)
{
path = service.GetPathOfAssembly(type.Assembly.GetName());
}
}
if (path == null)
{
path = type.Module.FullyQualifiedName;
}
string str4 = Path.GetDirectoryName(path) + @"\" + type.FullName + ".lic";
if (File.Exists(str4))
{
Stream stream = new FileStream(str4, FileMode.Open, FileAccess.Read, FileShare.Read);
StreamReader reader = new StreamReader(stream);
string key = reader.ReadLine();
reader.Close();
if (this.IsKeyValid(key, type))
{
license = new LicFileLicense(this, this.GetKey(type));
}
}
if (license != null)
{
context.SetSavedLicenseKey(type, license.LicenseKey);
}
}
return(license);
}
public override License GetLicense( LicenseContext context,
Type type,
object instance,
bool allowExceptions )
{
// We'll test for the usage mode...run time v. design time.
// Note we only check if run time...
if (context.UsageMode == LicenseUsageMode.Runtime)
{
// The Registry key we'll check
RegistryKey licenseKey =
Registry.CurrentUser.OpenSubKey("Software\\Acme\\HostKeys");
if (licenseKey != null)
{
// Passed the first test, which is the existence of the
// Registry key itself. Now obtain the stored value
// associated with our app's GUID.
string strLic =
(string)licenseKey.GetValue(type.GUID.ToString()); // reflected!
if (strLic != null)
{
// Passed the second test, which is some value
// exists that's associated with our app's GUID.
if (String.Compare("Installed", strLic, false) == 0)
{
// Got it...valid license...
return new RuntimeRegistryLicense(type);
} // if
} // if
} // if
// if we got this far, we failed the license test. We then
// check to see if exceptions are allowed, and if so, throw
// a new license exception...
if (allowExceptions == true)
{
throw new LicenseException(type,
instance,
"Your license is invalid");
} // if
// Exceptions are not desired, so we'll simply return null.
return null;
} // if
else
{
return new DesigntimeRegistryLicense(type);
} // else
}
public override License GetLicense(LicenseContext context,
Type type, object instance, bool allowExceptions)
{
// return new RegLicense(this, type);
// if (context.UsageMode == LicenseUsageMode.Designtime)
// {
// RegistryKey licenseKey = Registry.LocalMachine.
// OpenSubKey("Software\\MindFusion Limited\\ComponentLicenses");
// if (licenseKey == null)
// {
// // the conrol might be installed on a 64-bit system
// licenseKey = Registry.LocalMachine.
// OpenSubKey("Software\\Wow6432Node\\MindFusion Limited\\ComponentLicenses");
// }
// if (licenseKey != null)
// {
// object keyVal = licenseKey.GetValue(type.FullName);
// if (keyVal != null)
// {
//#if DEMO_VERSION
// return new RegLicense(this, type);
//#else
//#if FCNET_STD
// if (keyVal.ToString() == "fcxstd_lic_sG9VJ4sL")
// return new RegLicense(this, type);
//#else
// if (keyVal.ToString() == "fcxpro_lic_FO7cGAk")
// return new RegLicense(this, type);
//#endif
//#endif
// }
// }
// if (allowExceptions)
// {
// throw new LicenseException(type, instance,
// "Couldn''t get design-time license for ''" + type.FullName + "''");
// }
// return null;
// }
// else
{
return new RuntimeRegLicense(this, type);
}
}
// The CLR invokes this when instantiating an unmanaged COM
// object. The purpose is to decide which classfactory method to
// use.
//
// If the current context is design time, the CLR will
// use ICF::CreateInstance().
//
// If the current context is runtime and the current context
// exposes a non-null license key and the COM object supports
// IClassFactory2, the CLR will use ICF2::CreateInstanceLic().
// Otherwise, the CLR will use ICF::CreateInstance.
//
// Arguments:
// ref int fDesignTime: on exit, this will be set to indicate
// the nature of the current license context.
// ref int bstrKey: on exit, this will point to the
// licensekey saved inside the license context.
// (only if the license context is runtime)
// RuntimeTypeHandle rth: the managed type of the wrapper
private void GetCurrentContextInfo(ref int fDesignTime, ref IntPtr bstrKey, RuntimeTypeHandle rth)
{
this.savedLicenseContext = LicenseManager.CurrentContext;
this.savedType = Type.GetTypeFromHandle(rth);
if (this.savedLicenseContext.UsageMode == LicenseUsageMode.Designtime)
{
fDesignTime = 1;
bstrKey = (IntPtr)0;
}
else
{
fDesignTime = 0;
String key = this.savedLicenseContext.GetSavedLicenseKey(this.savedType, null);
bstrKey = Marshal.StringToBSTR(key);
}
}
// Used to validate a type and retrieve license details
// when activating a managed COM server from an IClassFactory2 instance.
public static bool ValidateAndRetrieveLicenseDetails(
LicenseContext context,
Type type,
out License?license,
out string?licenseKey)
{
context ??= LicenseManager.CurrentContext;
return(LicenseManager.ValidateInternalRecursive(
context,
type,
instance: null,
allowExceptions: false,
out license,
out licenseKey));
}
public static Object CreateWithContext
(Type type, LicenseContext creationContext, Object[] args)
{
lock (typeof(LicenseManager))
{
// Temporarily switch to the new context during creation.
LicenseContext savedContext = currentContext;
currentContext = creationContext;
try
{
// Make sure that we are the only context user.
if (ourLock == null)
{
ourLock = new Object();
}
LockContext(ourLock);
try
{
try
{
return(Activator.CreateInstance(type, args));
}
catch (TargetInvocationException e)
{
// Re-throw the inner exception, if present.
if (e.InnerException != null)
{
throw e.InnerException;
}
else
{
throw;
}
}
}
finally
{
UnlockContext(ourLock);
}
}
finally
{
currentContext = savedContext;
}
}
}
/// <summary>
/// Get license from registry. If not expired and is valid then use it
/// </summary>
/// <param name="context"></param>
/// <param name="type"></param>
/// <param name="instance"></param>
/// <param name="allowExceptions"></param>
/// <returns></returns>
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
// Get license only in design mode
if (context.UsageMode == LicenseUsageMode.Designtime)
{
// check and create license
AxiomLicense lic = new AxiomLicense();
// Trial license
System.Windows.Forms.MessageBox.Show("Please register ME!");
return lic;
}
else
{
return new AxiomLicense();
}
}
public override License GetLicense(LicenseContext context,
Type type, object instance, bool allowExceptions)
{
#if (DEMO)
if (context.UsageMode == LicenseUsageMode.Designtime || Debugger.IsAttached) {
return new DemoLicense(true);
}
else {
bool runSpecial = false;
try {
LocalDataStoreSlot slot = Thread.GetNamedDataSlot("Wilson.ORMapper.AllowDemo");
string allowDemoKey = Thread.GetData(slot) as string;
if (allowDemoKey != null) {
if (allowDemoKey.Equals("WilsonWebPortal")) runSpecial = true;
else if (allowDemoKey.Equals("WilsonORHelper")) runSpecial = true;
}
}
catch {} // Do Nothing
bool runMatrix = false;
if (!runSpecial) {
try {
if (Process.GetProcessesByName("WebMatrix").Length > 0) runMatrix = true;
else if (Process.GetProcessesByName("WebServer").Length > 0) runMatrix = true;
}
catch {} // Do Nothing
}
if (runSpecial || runMatrix) {
return new DemoLicense(true);
}
else {
return null;
}
}
#else
return new DemoLicense(false);
#endif
}
// The CLR invokes this when instantiating an unmanaged COM
// object. The purpose is to decide which classfactory method to
// use.
//
// If the current context is design time, the CLR will
// use ICF::CreateInstance().
//
// If the current context is runtime and the current context
// exposes a non-null license key and the COM object supports
// IClassFactory2, the CLR will use ICF2::CreateInstanceLic().
// Otherwise, the CLR will use ICF::CreateInstance.
//
// Arguments:
// ref int fDesignTime: on exit, this will be set to indicate
// the nature of the current license context.
// ref int bstrKey: on exit, this will point to the
// licensekey saved inside the license context.
// (only if the license context is runtime)
// RuntimeTypeHandle rth: the managed type of the wrapper
private void GetCurrentContextInfo(ref int fDesignTime, ref IntPtr bstrKey, RuntimeTypeHandle rth) {
this.savedLicenseContext = LicenseManager.CurrentContext;
this.savedType = Type.GetTypeFromHandle(rth);
if (this.savedLicenseContext.UsageMode == LicenseUsageMode.Designtime) {
fDesignTime = 1;
bstrKey = (IntPtr)0;
}
else {
fDesignTime = 0;
String key = this.savedLicenseContext.GetSavedLicenseKey(this.savedType, null);
bstrKey = Marshal.StringToBSTR(key);
}
}
/// <include file='doc\LicenseManager.uex' path='docs/doc[@for="LicenseManager.CreateWithContext"]/*' />
/// <devdoc>
/// <para>Creates an instance of the specified type, using
/// creationContext
/// as the context in which the licensed instance can be used.</para>
/// </devdoc>
public static object CreateWithContext(Type type, LicenseContext creationContext) {
return CreateWithContext(type, creationContext, new object[0]);
}
/// <include file='doc\LicenseManager.uex' path='docs/doc[@for="LicenseManager.ValidateInternalRecursive"]/*' />
/// <devdoc>
/// Since we want to walk up the entire inheritance change, when not
/// give an instance, we need another helper method to walk up
/// the chain...
/// </devdoc>
private static bool ValidateInternalRecursive(LicenseContext context, Type type, object instance, bool allowExceptions, out License license, out string licenseKey)
{
LicenseProvider provider = GetCachedProvider(type);
if (provider == null && !GetCachedNoLicenseProvider(type))
{
// NOTE : Must look directly at the class, we want no inheritance.
//
LicenseProviderAttribute attr = (LicenseProviderAttribute)Attribute.GetCustomAttribute(type, typeof(LicenseProviderAttribute), false);
if (attr != null)
{
Type providerType = attr.LicenseProvider;
provider = GetCachedProviderInstance(providerType);
if (provider == null)
{
provider = (LicenseProvider)SecurityUtils.SecureCreateInstance(providerType);
}
}
CacheProvider(type, provider);
}
license = null;
bool isValid = true;
licenseKey = null;
if (provider != null)
{
license = provider.GetLicense(context, type, instance, allowExceptions);
if (license == null)
{
isValid = false;
}
else
{
// For the case where a COM client is calling "RequestLicKey",
// we try to squirrel away the first found license key
//
licenseKey = license.LicenseKey;
}
}
// When looking only at a type, we need to recurse up the inheritence
// chain, however, we can't give out the license, since this may be
// from more than one provider.
//
if (isValid && instance == null)
{
Type baseType = type.BaseType;
if (baseType != typeof(object) && baseType != null)
{
if (license != null)
{
license.Dispose();
license = null;
}
string temp;
isValid = ValidateInternalRecursive(context, baseType, null, allowExceptions, out license, out temp);
if (license != null)
{
license.Dispose();
license = null;
}
}
}
return(isValid);
}
public override License GetLicense(LicenseContext context, Type type, Object instance, bool allowExceptions)
{
return(default(License));
}
// Get the license for a type.
public override License GetLicense
(LicenseContext context, Type type, object instance,
bool allowExceptions)
{
String key, path;
StreamReader reader;
// Bail out if we don't have a license context.
if(context == null)
{
return null;
}
// Use the saved key if we saw this type previously.
if(context.UsageMode == LicenseUsageMode.Runtime)
{
key = context.GetSavedLicenseKey(type, null);
if(key != null && IsKeyValid(key, type))
{
return new FileLicense(key);
}
}
// Find the pathname of the assembly containing the type.
#if CONFIG_COMPONENT_MODEL_DESIGN
ITypeResolutionService trs;
trs = (ITypeResolutionService)
context.GetService(typeof(ITypeResolutionService));
if(trs != null)
{
path = trs.GetPathOfAssembly(type.Assembly.GetName());
if(path == null)
{
path = type.Assembly.Location;
}
}
else
#endif
{
path = type.Assembly.Location;
}
// Look for a "*.lic" file for the type.
path = Path.Combine(Path.GetDirectoryName(path),
type.FullName + ".lic");
try
{
reader = new StreamReader(path);
}
catch(Exception)
{
// Could not open the file, so assume unlicensed.
return null;
}
// Read the key from the first line of the license file.
key = reader.ReadLine();
reader.Close();
// Bail out if the key is invalid.
if(key == null || !IsKeyValid(key, type))
{
return null;
}
// Cache the key within the context.
context.SetSavedLicenseKey(type, key);
// Return a new file license to the caller.
return new FileLicense(key);
}
/// <summary>
/// Creates an instance of the specified type, using
/// creationContext
/// as the context in which the licensed instance can be used.
/// </summary>
public static object CreateWithContext(Type type, LicenseContext creationContext)
{
return(CreateWithContext(type, creationContext, Array.Empty <object>()));
}
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
return new EncryptedLicense();
}
/// <summary>
/// Return the license key for the given context and type
/// </summary>
/// <remarks>
/// This can be overridden to change where the license key is stored by the provider. For
/// instance a derived class could override this method to store the key in the Registry.
/// </remarks>
/// <param name="context">The license context</param>
/// <param name="type">The type to get the key for</param>
/// <returns>The license key</returns>
protected virtual string GetLicenseKey(LicenseContext context, Type type)
{
string key = null;
if (context.UsageMode == LicenseUsageMode.Runtime)
{
try
{
key = context.GetSavedLicenseKey(type, null);
}
catch
{
// if something goes wrong retrieving the saved license key then just ignore it
// and try reading from file
}
}
// if we're in design mode or a suitable license key wasn't found in
// the runtime context look for a .LIC file
//
if (key == null)
{
key = ReadKeyFromFile(GetLicenseFilePath(context, type));
}
return key;
}
// Get the license for a type.
public override License GetLicense
(LicenseContext context, Type type, object instance,
bool allowExceptions)
{
String key, path;
StreamReader reader;
// Bail out if we don't have a license context.
if (context == null)
{
return(null);
}
// Use the saved key if we saw this type previously.
if (context.UsageMode == LicenseUsageMode.Runtime)
{
key = context.GetSavedLicenseKey(type, null);
if (key != null && IsKeyValid(key, type))
{
return(new FileLicense(key));
}
}
// Find the pathname of the assembly containing the type.
#if CONFIG_COMPONENT_MODEL_DESIGN
ITypeResolutionService trs;
trs = (ITypeResolutionService)
context.GetService(typeof(ITypeResolutionService));
if (trs != null)
{
path = trs.GetPathOfAssembly(type.Assembly.GetName());
if (path == null)
{
path = type.Assembly.Location;
}
}
else
#endif
{
path = type.Assembly.Location;
}
// Look for a "*.lic" file for the type.
path = Path.Combine(Path.GetDirectoryName(path),
type.FullName + ".lic");
try
{
reader = new StreamReader(path);
}
catch (Exception)
{
// Could not open the file, so assume unlicensed.
return(null);
}
// Read the key from the first line of the license file.
key = reader.ReadLine();
reader.Close();
// Bail out if the key is invalid.
if (key == null || !IsKeyValid(key, type))
{
return(null);
}
// Cache the key within the context.
context.SetSavedLicenseKey(type, key);
// Return a new file license to the caller.
return(new FileLicense(key));
}
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
int num2;
string[] textArray1;
string text1 = "\nEnvironment info:\n";
text1 = text1 + "version: " + DiagramView.VersionName + "\n";
if (Assembly.GetEntryAssembly() != null)
{
text1 = text1 + "entry: ";
try
{
text1 = text1 + Assembly.GetEntryAssembly().FullName;
}
catch (SecurityException)
{
text1 = text1 + "?fn?";
}
object obj1 = null;
try
{
obj1 = Assembly.GetEntryAssembly().EntryPoint;
}
catch (SecurityException)
{
text1 = text1 + "?ep?";
}
if (obj1 != null)
{
text1 = text1 + ", has entry point\n";
}
else
{
text1 = text1 + ", no entry point\n";
}
}
else
{
text1 = text1 + "null entry\n";
}
int num1 = 0;
string text2 = "";
try
{
try
{
text2 = context.GetSavedLicenseKey(type, null);
}
catch (SecurityException exception1)
{
text2 = null;
text1 = text1 + "\n" + exception1.ToString();
}
if (text2 != null)
{
text1 = text1 + "key: " + text2 + "\n";
}
else
{
text1 = text1 + "null key\n";
}
if ((text2 != null) && (text2.Length != 0))
{
goto Label_01AF;
}
try
{
Assembly[] assemblyArray1 = AppDomain.CurrentDomain.GetAssemblies();
Assembly[] assemblyArray2 = assemblyArray1;
for (num2 = 0; num2 < assemblyArray2.Length; num2++)
{
Assembly assembly1 = assemblyArray2[num2];
text1 = text1 + assembly1.FullName + "\n";
try
{
text2 = context.GetSavedLicenseKey(type, assembly1);
}
catch (SecurityException)
{
text2 = null;
}
if ((text2 != null) && (text2.Length > 0))
{
goto Label_015A;
}
}
}
catch (SecurityException)
{
}
Label_015A:
text1 = text1 + DiagramView.myVersionName + "\n";
if (DiagramView.myVersionAssembly != null)
{
text1 = text1 + DiagramView.myVersionAssembly.GetName().Name + "\n";
}
else
{
text1 = text1 + "null licensed assembly\n";
}
if (DiagramView.myVersionName.Length > 0x18)
{
text2 = DiagramView.myVersionName;
}
Label_01AF:
if ((text2 != null) && (text2.Length > 0))
{
num1 = this.Dispose(text2, true);
if (num1 == 4)
{
return new DiagramViewLicense(text2, num1);
}
}
else
{
text2 = "";
RegistryKey key1 = null;
try
{
key1 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Northwoods Software\Go.NET");
}
catch (SecurityException exception2)
{
text1 = text1 + "\n" + exception2.ToString();
}
if (key1 == null)
{
try
{
key1 = Registry.LocalMachine.OpenSubKey(@"SOFTWARE\Northwoods Software\GoDiagram");
}
catch (SecurityException)
{
}
}
if (key1 != null)
{
string text3 = type.Assembly.GetName().Name;
object obj2 = null;
try
{
obj2 = key1.GetValue(text3);
}
catch (SecurityException)
{
}
if ((obj2 != null) && (obj2 is byte[]))
{
text2 = Convert.ToBase64String((byte[])obj2);
}
}
num1 = this.Dispose(text2, false);
if ((num1 == 0) && (key1 != null))
{
text2 = "";
string text4 = type.Assembly.GetName().Name + " eval";
object obj3 = null;
try
{
obj3 = key1.GetValue(text4);
}
catch (SecurityException)
{
}
if ((obj3 != null) && (obj3 is byte[]))
{
text2 = Convert.ToBase64String((byte[])obj3);
}
num1 = this.Dispose(text2, false);
}
if ((num1 >= 4) && (context.UsageMode == LicenseUsageMode.Designtime))
{
context.SetSavedLicenseKey(type, text2);
}
if ((num1 == 4) || (context.UsageMode == LicenseUsageMode.Designtime))
{
return new DiagramViewLicense(text2, num1);
}
}
}
catch (Exception exception3)
{
text1 = text1 + "\n" + exception3.ToString();
}
num2 = num1 & 3;
switch (num2)
{
case 1:
{
string text7 = (num1 > 4) ? "beta" : "evaluation";
textArray1 = new string[0x10] { "Built using ", DiagramViewLicenseProvider.GONAME, " for .NET Windows Forms ", this.StringFloat(DiagramView.Version), Environment.NewLine, "Copyright \x00a9 Northwoods Software, 1998-2004. All Rights Reserved.", Environment.NewLine, "This ", text7, " copy of ", DiagramViewLicenseProvider.GONAME, " is about to expire.", Environment.NewLine, Environment.NewLine, "DO NOT DISTRIBUTE OR DEPLOY THIS SOFTWARE.", Environment.NewLine };
string text8 = string.Concat(textArray1);
if (num1 < 4)
{
text8 = text8 + Environment.NewLine + "Please purchase a license at www.nwoods.com" + Environment.NewLine;
}
if (SystemInformation.UserInteractive)
{
MessageBox.Show(text8, type.Name + " License Check", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
Console.WriteLine(type.Name + " License Check");
Console.WriteLine(text8);
}
return new DiagramViewLicense(text8, num1);
}
case 2:
{
string text5 = (num1 > 4) ? "beta" : "evaluation";
textArray1 = new string[14] { "Built using ", DiagramViewLicenseProvider.GONAME, " for .NET Windows Forms ", this.StringFloat(DiagramView.Version), Environment.NewLine, "Copyright \x00a9 Northwoods Software, 1998-2004. All Rights Reserved.", Environment.NewLine, "This software is licensed for a limited ", text5, " period.", Environment.NewLine, Environment.NewLine, "DO NOT DISTRIBUTE OR DEPLOY THIS SOFTWARE.", Environment.NewLine };
string text6 = string.Concat(textArray1);
if (num1 < 4)
{
text6 = text6 + Environment.NewLine + "Please purchase a license at www.nwoods.com" + Environment.NewLine;
}
if (SystemInformation.UserInteractive)
{
if (!DiagramViewLicenseProvider.err)
{
DiagramViewLicenseProvider.err = true;
MessageBox.Show(text6, type.Name + " License Check", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
}
else
{
Console.WriteLine(type.Name + " License Check");
Console.WriteLine(text6);
}
return new DiagramViewLicense(text6, num1);
}
}
textArray1 = new string[0x1c] {
"Built using ", DiagramViewLicenseProvider.GONAME, " for .NET Windows Forms ", this.StringFloat(DiagramView.Version), Environment.NewLine, "Copyright \x00a9 Northwoods Software, 1998-2004. All Rights Reserved.", Environment.NewLine, "The license for this copy of ", DiagramViewLicenseProvider.GONAME, " is invalid or has expired.", Environment.NewLine, Environment.NewLine, "Please purchase a license at www.nwoods.com", Environment.NewLine, "If you have already purchased a ", DiagramViewLicenseProvider.GONAME,
" development license,", Environment.NewLine, " have you requested an Unlock Code for your development machine by running the GoDiagram LicenseManager?", Environment.NewLine, "If you have already entered an Unlock Code in the LicenseManager,", Environment.NewLine, " did you link license objects into your application via the Microsoft license compiler?", Environment.NewLine, " (Make sure the needed components and correct VERSION are listed in the LICENSES.LICX file,", Environment.NewLine, " and that the LICENSES.LICX file is part of your EXECUTABLE's project, not in a DLL.)", Environment.NewLine
};
string text9 = string.Concat(textArray1);
text9 = text9 + text1;
if (SystemInformation.UserInteractive)
{
MessageBox.Show(text9, type.Name + " License Check", MessageBoxButtons.OK, MessageBoxIcon.Exclamation);
}
else
{
Console.WriteLine(type.Name + " License Check");
Console.WriteLine(text9);
}
if (allowExceptions)
{
throw new LicenseException(type, instance, text9);
}
return null;
}
/// <include file='doc\LicFileLicenseProvider.uex' path='docs/doc[@for="LicFileLicenseProvider.GetLicense"]/*' />
/// <devdoc>
/// <para>Gets a license for the instance of the component and determines if it is valid.</para>
/// </devdoc>
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
ProcCountLicense lic = null;
Debug.Assert(context != null, "No context provided!");
//if no context is provided, do nothing
if (context != null)
{
//if this control is in runtime mode
if (context.UsageMode == LicenseUsageMode.Runtime)
{
//retreive the stored license key
string key = context.GetSavedLicenseKey(type, null);
//check if the stored license key is null
// and call IsKeyValid to make sure its valid
if (key != null && IsKeyValid(key, type))
{
//if the key is valid create a new license
lic = new ProcCountLicense(this, key);
}
}
//if we're in design mode or
//a suitable license key wasn't found in
//the runtime context.
//attempt to look for a .LIC file
if (lic == null)
{
//build up the path where the .LIC file
//should be
string modulePath = null;
// try and locate the file for the assembly
if (context != null)
{
ITypeResolutionService resolver = (ITypeResolutionService)context.GetService(typeof(ITypeResolutionService));
if (resolver != null)
modulePath = resolver.GetPathOfAssembly(type.Assembly.GetName());
}
if (modulePath == null)
modulePath = type.Module.FullyQualifiedName;
//get the path from the file location
string moduleDir = Path.GetDirectoryName(modulePath);
//build the path of the .LIC file
string licenseFile = moduleDir + "\\" + type.FullName + ".lic";
Debug.WriteLine("Path of license file: " + licenseFile);
//if the .LIC file exists, dig into it
if (File.Exists(licenseFile))
{
//crack the file and get the first line
Stream licStream = new FileStream(licenseFile, FileMode.Open, FileAccess.Read, FileShare.Read);
StreamReader sr = new StreamReader(licStream);
string s = sr.ReadLine();
sr.Close();
Debug.WriteLine("Contents of license file: " + s);
//check if the key is valid
if (IsKeyValid(s, type))
{
//valid key so create a new License
lic = new ProcCountLicense(this, s);
}
}
//if we managed to create a license, stuff it into the context
if (lic != null)
{
context.SetSavedLicenseKey(type, lic.LicenseKey);
}
}
}
return lic;
}
/// <summary>
/// Extract the license for the given type from the given licenseKey
/// </summary>
/// <param name="context">The current licensing context</param>
/// <param name="type">The type to be licensed</param>
/// <param name="licenseKey">The encrypted hexadecimal license key</param>
/// <returns>A license for the given type or NULL if the licenseKey was invalid</returns>
protected virtual EncryptedLicense LoadLicense(LicenseContext context, Type type, string licenseKey)
{
// check that validation parameters have been set by the client
//
if (_designSignature == null || _runtimeSignature == null)
throw new InvalidOperationException("EncryptedLicenseProvider.SetParameters must be called prior to using the EncryptedLicenseProvider");
if (licenseKey == null) return null;
try
{
byte[] encData = FromHex(licenseKey);
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Key = _desKey;
des.IV = _desIV;
byte[] data = des.CreateDecryptor().TransformFinalBlock(encData, 0, encData.Length);
// extract the password data and encrypted product data
//
byte[] passwordData = new byte[ArraySize(_keyStrength)];
byte[] encPayload = new byte[ArraySize(data.Length - _keyStrength)];
// for key strengths greater than 8 the order of payload and key is swapped
//
if (_keyStrength < 8)
{
Array.Copy(data, 0, passwordData, 0, _keyStrength);
Array.Copy(data, _keyStrength, encPayload, 0, encPayload.Length);
}
else
{
Array.Copy(data, 0, encPayload, 0, encPayload.Length);
Array.Copy(data, encPayload.Length, passwordData, 0, _keyStrength);
}
// the key used to encrypt payload is just the first 7 bytes of the password data
//
byte[] encryptionKey = new byte[ArraySize(8)];
Array.Copy(passwordData, 0, encryptionKey, 0, 7);
// validate that the password matches what the client is expecting
//
CspParameters cspParams = new CspParameters();
// if we are running in a server or ASP then ensure that we use the machine CSP
// store to avoid problems.
//
if (!Environment.UserInteractive || UseMachineKeyStore)
{
cspParams.Flags = CspProviderFlags.UseMachineKeyStore;
}
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider(cspParams);
rsa.ImportParameters(_rsaParameters);
byte[] paddedPasswordData = PadPassword(passwordData);
if (context.UsageMode == LicenseUsageMode.Designtime)
{
// if design time license requested then the license MUST be a design license
//
if (!rsa.VerifyData(paddedPasswordData, new SHA1CryptoServiceProvider(), _designSignature)) return null;
}
else
{
// if runtime license requested then first check if the license is a runtime license
// also allow design licenses to work at runtime
//
if (!rsa.VerifyData(paddedPasswordData, new SHA1CryptoServiceProvider(), _runtimeSignature))
{
if (!rsa.VerifyData(paddedPasswordData, new SHA1CryptoServiceProvider(), _designSignature)) return null;
}
}
// decrypt the payload using the encryption key
//
des.IV = encryptionKey;
byte[] payload = des.CreateDecryptor().TransformFinalBlock(encPayload, 0, encPayload.Length);
int checksumLength = (_checksumProductInfo) ? 2 : 0;
byte[] productData = new byte[ArraySize(payload.Length - 2 - checksumLength)];
Array.Copy(payload, 2, productData, 0, productData.Length);
UInt16 serialNo = BitConverter.ToUInt16(payload, 0);
string product = System.Text.ASCIIEncoding.UTF8.GetString(productData);
// validate the product data checksum
//
if (_checksumProductInfo)
{
UInt16 requiredChecksum = BitConverter.ToUInt16(payload, payload.Length - checksumLength);
UInt16 actualChecksum = Checksum(productData);
if (requiredChecksum != actualChecksum)
return null;
}
// if in design time then create a runtime license and save it
//
if (context.UsageMode == LicenseUsageMode.Designtime && type != null)
{
// create the runtime password by encrypting the design password
//
byte[] encPassword = des.CreateEncryptor().TransformFinalBlock(paddedPasswordData, 0, paddedPasswordData.Length);
byte[] runtimePasswordData = new byte[ArraySize(_keyStrength)];
Array.Copy(encPassword, 0, runtimePasswordData, 0, _keyStrength);
string runtimeLicenseKey = GenerateKey(_keyStrength, runtimePasswordData, productData,_checksumProductInfo, serialNo);
// save the runtime key into the context
//
context.SetSavedLicenseKey(type, runtimeLicenseKey);
}
return new EncryptedLicense(licenseKey, serialNo, product);
}
catch
{
return null;
}
}
/// <summary>
/// <para>Creates an instance of the specified type with the
/// specified arguments, using creationContext as the context in which the licensed
/// instance can be used.</para>
/// </summary>
public static object CreateWithContext(Type type, LicenseContext creationContext, object[] args)
{
object created = null;
lock (s_internalSyncObject)
{
LicenseContext normal = CurrentContext;
try
{
CurrentContext = creationContext;
LockContext(s_selfLock);
try
{
created = SecurityUtils.SecureCreateInstance(type, args);
}
catch (TargetInvocationException e)
{
throw e.InnerException;
}
}
finally
{
UnlockContext(s_selfLock);
CurrentContext = normal;
}
}
return created;
}
/// <summary>
/// Since we want to walk up the entire inheritance change, when not
/// give an instance, we need another helper method to walk up
/// the chain...
/// </summary>
private static bool ValidateInternalRecursive(LicenseContext context, Type type, object?instance, bool allowExceptions, out License?license, out string?licenseKey)
{
LicenseProvider?provider = GetCachedProvider(type);
if (provider == null && !GetCachedNoLicenseProvider(type))
{
// NOTE : Must look directly at the class, we want no inheritance.
LicenseProviderAttribute?attr = (LicenseProviderAttribute?)Attribute.GetCustomAttribute(type, typeof(LicenseProviderAttribute), false);
if (attr != null)
{
Type providerType = attr.LicenseProvider !;
provider = GetCachedProviderInstance(providerType) ?? (LicenseProvider)Activator.CreateInstance(providerType) !;
}
CacheProvider(type, provider);
}
license = null;
bool isValid = true;
licenseKey = null;
if (provider != null)
{
license = provider.GetLicense(context, type, instance, allowExceptions);
if (license == null)
{
isValid = false;
}
else
{
// For the case where a COM client is calling "RequestLicKey",
// we try to squirrel away the first found license key
licenseKey = license.LicenseKey;
}
}
// When looking only at a type, we need to recurse up the inheritance
// chain, however, we can't give out the license, since this may be
// from more than one provider.
if (isValid && instance == null)
{
Type?baseType = type.BaseType;
if (baseType != typeof(object) && baseType != null)
{
if (license != null)
{
license.Dispose();
#pragma warning disable IDE0059 // ValidateInternalRecursive does not null licence all the time (https://github.com/dotnet/roslyn/issues/42761)
license = null;
#pragma warning restore IDE0059
}
isValid = ValidateInternalRecursive(context, baseType, null, allowExceptions, out license, out _);
if (license != null)
{
license.Dispose();
license = null;
}
}
}
return(isValid);
}
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
throw new NotImplementedException();
}
/// <summary>
/// Return the license for the given type from a given DLL assembly resources
/// </summary>
/// <param name="context">The license context to validate the license in</param>
/// <param name="assembly">The assembly containing the license</param>
/// <param name="type">The type to get the license for</param>
/// <returns>The license key if any</returns>
/// <remarks>
/// This method can be used to check the given DLL assembly for a license. By default the .NET licensing
/// framework only checks the entry assembly (ie typically executables) for licenses. This means
/// that if a licensed control is wrapped in another control, the customer of the wrapped control will
/// still required a design time license key for the original control. This is generally the behaviour
/// that control authors would like. If however you want to provide a license that enables a customer
/// to create new component/controls using your control/component then you can achieve this by using
/// this method to check for a license in the CallingAssembly that created the control/component.
/// </remarks>
public virtual EncryptedLicense GetLicense(LicenseContext context, Assembly assembly, Type type)
{
if (assembly == null) return null;
EncryptedLicense license = null;
string licenseKey = GetSavedLicenseKey(assembly, type);
if (licenseKey != null)
{
license = LoadLicense(context, null, licenseKey);
}
return license;
}
public abstract License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions);
public static object CreateWithContext(
[DynamicallyAccessedMembers(DynamicallyAccessedMemberTypes.PublicConstructors)] Type type,
LicenseContext creationContext)
{
return(CreateWithContext(type, creationContext, Array.Empty <object>()));
}
// Get the license for a type. public abstract License GetLicense (LicenseContext context, Type type, Object instance, bool allowExceptions);
// Get the license for a type.
public override License GetLicense
(LicenseContext context, Type type, Object instance,
bool allowExceptions)
{
return(new DefaultLicense(type.FullName));
}
/// <summary>
/// Return the directory used to store license files
/// </summary>
/// <param name="context">The licence context</param>
/// <param name="type">The type being licensed</param>
/// <returns>The directory to look for license files</returns>
protected virtual string GetLicenseDirectory(LicenseContext context, Type type)
{
string result = null;
// try to use the type resolver service if available
//
if (context != null && type != null)
{
ITypeResolutionService resolver = (ITypeResolutionService)context.GetService(typeof(ITypeResolutionService));
if (resolver != null)
result = resolver.GetPathOfAssembly(type.Assembly.GetName());
}
if (result == null)
{
if (type == null)
{
result = AppDomain.CurrentDomain.BaseDirectory;
}
else
{
Assembly assembly = type.Assembly;
// use the code base if possible
//
result = assembly.CodeBase;
if (result.StartsWith(@"file:///"))
{
result = result.Replace(@"file:///", "");
}
else
{
result = type.Module.FullyQualifiedName;
}
}
}
return Path.GetDirectoryName(result);
}
public static Object CreateWithContext(Type type, LicenseContext creationContext)
{
return(default(Object));
}
/// <summary>
/// Get a license (if installed) for the given context, type and instance
/// </summary>
/// <param name="context">The context (design or runtime)</param>
/// <param name="type">The type to get the license for</param>
/// <param name="instance"></param>
/// <param name="allowExceptions">If true LicenseException is thrown if a valid license cannot be loaded</param>
/// <returns>An encrypted license</returns>
public override License GetLicense(LicenseContext context, Type type, object instance, bool allowExceptions)
{
string licenseKey = GetLicenseKey(context, type);
License license = LoadLicense(context, type, licenseKey);
if (license == null && allowExceptions)
{
if (instance == null)
throw new LicenseException(type);
else
throw new LicenseException(type, instance);
}
return license;
}
/// <include file='doc\LicenseManager.uex' path='docs/doc[@for="LicenseManager.CreateWithContext"]/*' />
/// <devdoc>
/// <para>Creates an instance of the specified type, using
/// creationContext
/// as the context in which the licensed instance can be used.</para>
/// </devdoc>
public static object CreateWithContext(Type type, LicenseContext creationContext)
{
return(CreateWithContext(type, creationContext, new object[0]));
}
/// <summary>
/// Return the directory used to store license files
/// </summary>
/// <param name="context">The licence context</param>
/// <param name="type">The type being licensed</param>
/// <returns>The directory to look for license files</returns>
protected virtual string GetLicenseDirectory(LicenseContext context, Type type)
{
string result = null;
// try to use the type resolver service if available
//
if (context != null)
{
ITypeResolutionService resolver = (ITypeResolutionService)context.GetService(typeof(ITypeResolutionService));
if (resolver != null)
result = resolver.GetPathOfAssembly(type.Assembly.GetName());
}
if (result == null)
{
// use the code base if possible - because this works properly under ASP.NET
// where as the Module.FullyQualifiedName points to a temporary file
//
result = type.Assembly.CodeBase;
if (result.StartsWith(@"file:///"))
{
result = result.Replace(@"file:///", "");
}
else
{
result = type.Module.FullyQualifiedName;
}
}
return Path.GetDirectoryName(result);
}
public static object CreateWithContext(Type type, LicenseContext creationContext, object[] args)
{
throw new NotImplementedException();
}
/// <summary>
/// Called by GetLicenseKey to get the file path to obtain the license from (if there is no runtime license saved in the context)
/// </summary>
/// <remarks>
/// This can be overridden to change the file used to store the design time license for the provider. By default the
/// the license file is stored in the same directory as the component executable with the name based on the fully
/// qualified type name eg MyNamespace.MyControl.lic
/// </remarks>
/// <seealso cref="GetLicenseKey"/>
/// <param name="context">The licence context</param>
/// <param name="type">The type to get the license for</param>
/// <returns>The path of the license file</returns>
protected virtual string GetLicenseFilePath(LicenseContext context, Type type)
{
string dir = GetLicenseDirectory(context, type);
return String.Format(@"{0}\{1}.lic", dir, type.FullName);
}
/// <include file='doc\LicenseManager.uex' path='docs/doc[@for="LicenseManager.ValidateInternalRecursive"]/*' />
/// <devdoc>
/// Since we want to walk up the entire inheritance change, when not
/// give an instance, we need another helper method to walk up
/// the chain...
/// </devdoc>
private static bool ValidateInternalRecursive(LicenseContext context, Type type, object instance, bool allowExceptions, out License license, out string licenseKey) {
LicenseProvider provider = GetCachedProvider(type);
if (provider == null && !GetCachedNoLicenseProvider(type)) {
// NOTE : Must look directly at the class, we want no inheritance.
//
LicenseProviderAttribute attr = (LicenseProviderAttribute)Attribute.GetCustomAttribute(type, typeof(LicenseProviderAttribute), false);
if (attr != null) {
Type providerType = attr.LicenseProvider;
provider = GetCachedProviderInstance(providerType);
if (provider == null) {
provider = (LicenseProvider)SecurityUtils.SecureCreateInstance(providerType);
}
}
CacheProvider(type, provider);
}
license = null;
bool isValid = true;
licenseKey = null;
if (provider != null) {
license = provider.GetLicense(context, type, instance, allowExceptions);
if (license == null) {
isValid = false;
}
else {
// For the case where a COM client is calling "RequestLicKey",
// we try to squirrel away the first found license key
//
licenseKey = license.LicenseKey;
}
}
// When looking only at a type, we need to recurse up the inheritence
// chain, however, we can't give out the license, since this may be
// from more than one provider.
//
if (isValid && instance == null) {
Type baseType = type.BaseType;
if (baseType != typeof(object) && baseType != null) {
if (license != null) {
license.Dispose();
license = null;
}
string temp;
isValid = ValidateInternalRecursive(context, baseType, null, allowExceptions, out license, out temp);
if (license != null) {
license.Dispose();
license = null;
}
}
}
return isValid;
}
/// <summary>
/// Return the license key for the given context and type
/// </summary>
/// <remarks>
/// This can be overridden to change where the license key is stored by the provider. For
/// instance a derived class could override this method to store the key in the Registry.
/// </remarks>
/// <param name="context">The license context</param>
/// <param name="type">The type to get the key for</param>
/// <returns>The license key</returns>
protected virtual string GetLicenseKey(LicenseContext context, Type type)
{
string key = null;
if (context.UsageMode == LicenseUsageMode.Runtime)
{
key = context.GetSavedLicenseKey(type, null);
}
// Try and loaded license from registry
if (key == null)
{
key = ReadKeyFromRegistry();
}
// if we're in design mode or a suitable license key wasn't found in
// the runtime context look for a .LIC file
//
if (key == null)
{
key = ReadKeyFromFile(GetLicenseFilePath(context, type));
}
return key;
}
/// <summary>
/// Extract the license for the given type from the given licenseKey
/// </summary>
/// <param name="context">The current licensing context</param>
/// <param name="type">The type to be licensed</param>
/// <param name="licenseKey">The encrypted hexadecimal license key</param>
/// <returns>A license for the given type or NULL if the licenseKey was invalid</returns>
private EncryptedLicense LoadLicense(LicenseContext context, Type type, string licenseKey)
{
// check that validation parameters have been set by the client
//
if (_rsaParameters == null || _designSignature == null || _runtimeSignature == null)
throw new InvalidOperationException("EncryptedLicenseProvider.SetParameters must be called prior to using the EncryptedLicenseProvider");
if (licenseKey == null) return null;
try
{
byte[] encData = FromHex(licenseKey);
DESCryptoServiceProvider des = new DESCryptoServiceProvider();
des.Key = _desKey;
des.IV = _desIV;
byte[] data = des.CreateDecryptor().TransformFinalBlock(encData, 0, encData.Length);
// extract the encryption key and encrypted product data - note that the encryption
// key has only 7 significant bytes
//
byte[] encryptionKey = new byte[ArraySize(8)];
byte[] encPayload = new byte[ArraySize(data.Length - keyLength)];
Array.Copy(data, 0, encryptionKey, 0, keyLength);
Array.Copy(data, keyLength, encPayload, 0, encPayload.Length);
// validate that the password matches what the client is expecting
//
RSACryptoServiceProvider rsa = new RSACryptoServiceProvider();
rsa.FromXmlString(_rsaParameters);
if (context.UsageMode == LicenseUsageMode.Designtime)
{
// if design time license requested then the license MUST be a design license
//
if (!rsa.VerifyData(encryptionKey, new SHA1CryptoServiceProvider(), _designSignature)) return null;
}
else
{
// if runtime license requested then first check if the license is a runtime license
// also allow design licenses to work at runtime
//
if (!rsa.VerifyData(encryptionKey, new SHA1CryptoServiceProvider(), _runtimeSignature))
{
if (!rsa.VerifyData(encryptionKey, new SHA1CryptoServiceProvider(), _designSignature)) return null;
}
}
// decrypt the payload using the encryption key
//
des.IV = encryptionKey;
byte[] payload = des.CreateDecryptor().TransformFinalBlock(encPayload, 0, encPayload.Length);
byte[] productData = new byte[ArraySize(payload.Length - 2)];
Array.Copy(payload, 2, productData, 0, productData.Length);
UInt16 serialNo = BitConverter.ToUInt16(payload, 0);
string product = System.Text.ASCIIEncoding.UTF8.GetString(productData);
// if in design time then create a runtime license and save it
//
if (context.UsageMode == LicenseUsageMode.Designtime && type != null)
{
// create the runtime password by encrypting the design time license
//
byte[] encKey = des.CreateEncryptor().TransformFinalBlock(encryptionKey, 0, encryptionKey.Length);
byte[] runtimeKey = new byte[ArraySize(8)];
Array.Copy(encKey, 0, runtimeKey, 0, keyLength);
// encrypt the payload using the runtime key
//
des.IV = runtimeKey;
encPayload = des.CreateEncryptor().TransformFinalBlock(payload, 0, payload.Length);
// Combine the runtime key and encrypted payload
// Note that only the first 7 bytes of the key contain information so we
// only pack this much information - this enables us to reduce the size of
// the final key by 8 bytes.
//
data = new byte[ArraySize(keyLength + encPayload.Length)];
runtimeKey.CopyTo(data, 0);
encPayload.CopyTo(data, keyLength);
// encrypt again to obscure the password - this time using preset encryption key
//
des.IV = _desIV;
encData = des.CreateEncryptor().TransformFinalBlock(data, 0, data.Length);
string runtimeLicenseKey = ToHex(encData);
// save the runtime key into the context
//
context.SetSavedLicenseKey(type, runtimeLicenseKey);
}
return new EncryptedLicense(licenseKey, serialNo, product);
}
catch
{
return null;
}
}
public static Object CreateWithContext(Type type, LicenseContext creationContext)
{
return default(Object);
}
