Пример #1
0
        void ValidateLicenseStrings()
        {
            bool allStringsAreValid = true;

            foreach (string s in licenseStrings)
            {
                LicenseKey licenseKey = new LicenseKey(s);
                if (!licenseKey.IsHashValid(masterKey))
                {
                    Console.WriteLine("License string {0} is not valid!", s);
                    allStringsAreValid = false;
                }
            }

            if (allStringsAreValid)
            {
                Console.WriteLine("[All license strings are valid.]");
            }
        }
Пример #2
0
        void Run(string[] args)
        {
            // Load default params from configuration file.
            LoadDefaultParams();

            // Override default params with any specified on command line.            
            ProcessCommandLine(args);
            
#if !INTERNAL
            if ( license.IsEvaluation )
            {
                System.Console.WriteLine();
                System.Console.WriteLine("Evaluation Version Note:");
                System.Console.WriteLine(
                    "  Because you have an evaluation version of License Express (tm), this\n" +
                    "  utility will only generate evaluation license keys with a maximum\n" +
                    "  expiration time of 2 days.  Visit http://www.wanderlust-software.com\n" +
                    "  to purchase a retail license which provides full functionality.\n" 
                    );

                LicenseKey licenseKey = new LicenseKey( license.LicenseKey );
                if  (
                    ( numberOfLicenseStringsToGenerate != 0 ) &&
                    ((!this.isEval) || (this.isEval && this.evalDays > 2)) 
                    )
                {
                    System.Console.Error.WriteLine(
                        "Keys not generated: Specify an evaluation license of 2 days or less.\n"+
                        "For example:\n"+
                        "  KeyGen /eval 2 /password \"My Password\" /count 5"
                        );                    
                    return;
                }
            }
#endif

            // Generate license strings.
            GenerateLicenseStrings();

            //ValidateLicenseStrings();

            // Write license strings to stdout.
            WriteStringsToStdout();

            // Write license strings to clipboard
            WriteStringsToClipboard();
            
        }
Пример #3
0
        void ValidateLicenseStrings()
        {
            bool allStringsAreValid = true;

            foreach(string s in licenseStrings)
            {
                LicenseKey licenseKey = new LicenseKey( s );
                if ( !licenseKey.IsHashValid(masterKey) )
                {
                    Console.WriteLine("License string {0} is not valid!", s);
                    allStringsAreValid = false;
                }
            }

            if ( allStringsAreValid )
            {
                Console.WriteLine("[All license strings are valid.]");
            }
        }
Пример #4
0
        void GenerateLicenseStrings()
        {            
            int currentSerialNumber = startingSerialNumber;

            licenseStrings = new string[numberOfLicenseStringsToGenerate];
            for(int i=0;i<numberOfLicenseStringsToGenerate;i++)
            {
                LicenseKey licenseKey = new LicenseKey();
				
				if ( expires )
				{
					licenseKey.Version = 2;
					licenseKey.Options = LicenseKeyOptions.AbsoluteExpirationDate;
					licenseKey.ExpirationDate = expirationDate;
				}
				
                if ( isEval )
                {
                    licenseKey.Type = LicenseKeyType.DesignTimeEvaluation;
                }
                else
                {
                    licenseKey.Type = LicenseKeyType.DesignTimeRetail;
                }

                licenseKey.EvaluationDays = evalDays;
                licenseKey.SerialNumber = currentSerialNumber;
                licenseKey.Hash = licenseKey.CalculateHash( masterKey );

                licenseStrings[i] = licenseKey.ToString();

                currentSerialNumber++;
            }
        }
Пример #5
0
        //
        // This routine gets the runtime license key associated with an
        // application.  It returns true if licence runtime key was
        // retrieved from registry, or created and stored in registry.
        // This is necessary ...
        //

        private bool GetApplicationRuntimeLicenseKey(LicenseKey licenseKey, Type type)
        {
            Microsoft.Win32.RegistryKey regKey = null;
            bool SuccessfulWriteToRegisty      = false;

            //
            // Here we check the registry to find if a runtime license exists.
            // If we do not find one, assume that this is the first time this
            // application is running.
            //

            String regKeyName = registryCacheName + "\\" + type.GUID.ToString();

            try
            {
                regKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(regKeyName, true);
            }
            catch (ArgumentException e)
            {
                Debug.WriteLine("Exception trying to read registry.");
                Debug.WriteLine(e);
                return(false);
            }
            catch (System.Security.SecurityException e)
            {
                Debug.WriteLine("Exception reading registry.");
                Debug.WriteLine(e);
                return(false);
            }


            if (regKey == null)
            {
                //
                // No key found in registry, so generate one and save it.
                //

                SuccessfulWriteToRegisty = GenerateRunTimeLicenseKeyFromDesignTime(licenseKey, type);

                //
                // If there was a problem writing to the registry,
                // return false thereby failing the license
                //

                if (!SuccessfulWriteToRegisty)
                {
                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                    return(false);
                }
                try
                {
                    regKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey(regKeyName, true);
                }
                catch (ArgumentException e)
                {
                    Debug.WriteLine("Exception trying to read registry.");
                    Debug.WriteLine(e);
                    return(false);
                }
                catch (System.Security.SecurityException e)
                {
                    Debug.WriteLine("Exception reading registry.");
                    Debug.WriteLine(e);
                    return(false);
                }
            }

            if (regKey != null)
            {
                this.licenseKeyString = (string)regKey.GetValue("License");
                if (this.licenseKeyString == null)
                {
                    //
                    // Someone probably deleted key manually.  Fail the license.
                    //

                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                    regKey.Close();
                    return(false);
                }

                regKey.Close();
            }
            else
            {
                licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                return(false);
            }



            //
            // this.licenseKeyString updated
            //

            return(true);
        }
Пример #6
0
        //
        //  GetKey() is defined by LicFileLicenseProvider.  It is called during
        //  GetLicense() processing in order to populate the LicenseKey property
        //  of the License object returned to the caller.
        //

        protected override string GetKey(Type type)
        {
            string     key;
            LicenseKey licenseKey;

            if (traceSwitch.TraceVerbose)
            {
                Trace.WriteLine(String.Format("GetKey(type={0})", type));
            }
            Trace.Indent();

            //
            // We return whichever license key string we were presented in IsKeyValid(),
            // unless we had been presented a 'design time evaluation' license.
            // In the latter case, we generate a new license key that encodes the
            // evaluation expiration date in it.  This license key will subsequenty
            // be embedded in the executable being built.
            //

            key = this.licenseKeyString;

            //
            // Myk, what do we do if we catch an exception here?  we should
            // never, because key should be valid.  If we return null, will we
            // still get a license?  In that case, we should never throw any
            // exceptions.
            //

            try
            {
                licenseKey = new LicenseKey(key);
            }
            catch (ArgumentException)
            {
                licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                return(null);
            }

            if (traceSwitch.TraceVerbose)
            {
                Trace.WriteLine("GetKey: License type is " + licenseKey.Type);
            }

            if (licenseKey.Type == LicenseKeyType.DesignTimeEvaluation)
            {
                //
                // Modify the license key to be a 'runtime evaluation' license by
                // changing its type, setting the expiration date, and recalculating
                // its hash value.
                //

                licenseKey.Type           = LicenseKeyType.RuntimeEvaluation;
                licenseKey.ExpirationDate = DateTime.Now.AddDays(licenseKey.EvaluationDays);
                licenseKey.Hash           = licenseKey.CalculateHash(licenseComponent.MasterLicensePassword);

                key = licenseKey.ToString();
            }

            if (traceSwitch.TraceVerbose)
            {
                Trace.WriteLine("Generated license key: " + key);
            }
            Trace.Unindent();

            //
            // Return the new license key string to be embedded.
            //

            return(key);
        }
Пример #7
0
        //
        // This routine gets the runtime license key assocaited with an
        // application.  This is necessary ...
        //protected LicenseKey GetApplicationRuntimeLicenseKey()
        //{
        //}


        //
        //  IsKeyValid is defined by LicFileLicenseProvider, and is called
        //  during processing of GetLicense to determine if a given license
        //  key string represents a valid license.
        //
        //  Notice that we are only given the string and the type of the
        //  class being licensed.  We need to use the LicXLicenseComponent
        //  that is a member of the licensed instance, so we pull that out
        //  of the class field where it had been stored earlier.
        //
        //  Note that in the case of an application licensed with an evaluation
        //  license, we may have to go to the registry to find an appropriate
        //  license key string.
        //

        protected override bool IsKeyValid(string licenseKeyString, Type type)
        {
            bool       keyIsValid;
            bool       RunTimKeyFound = false;
            LicenseKey licenseKey;

            if (traceSwitch.TraceVerbose)
            {
                Trace.WriteLine(String.Format("IsKeyValid({0}, {1})", licenseKeyString, type));
            }
            Trace.Indent();

            //
            // Save LicenseKeyString for later use in GetKey.  If this is a
            // runtime application using a design time key, it will be changed
            // and stored for GetKey()
            //

            this.licenseKeyString = licenseKeyString;

            //
            // Create a LicenseKey object with the given license key string.
            // The LicenseKey can throw an Exception for the int32.parse
            // method.  Fail it if does, b/c something is a matter with our
            // license key string.
            //

            try
            {
                licenseKey = new LicenseKey(licenseKeyString);
            }
            catch (ArgumentException)
            {
                licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                return(false);
            }

            //
            // If we are being invoked at runtime, and the license key string
            // we are given is of type "design time evaluation", we are dealing
            // with a licensed application (as opposed to a component).  In
            // this case, the runtime license we use needs to be in the
            // registry.  (The first time the application is run, we need to
            // create this registry license).
            //
            // BUGBUG: It doesn't appear that the check for
            // BUGBUG: "!licenseKey.AbsoluteExpirationDate is ever needed?
            // BUGBUG: Need to do a full test cycle to make sure...
            //

            if (
                (LicenseManager.CurrentContext.UsageMode == LicenseUsageMode.Runtime) &&
                (licenseKey.Type == LicenseKeyType.DesignTimeEvaluation) &&
                (!licenseKey.AbsoluteExpirationDate)
                )
            {
                RunTimKeyFound = GetApplicationRuntimeLicenseKey(licenseKey, type);

                if (!RunTimKeyFound)
                {
                    // there was a problem writing or reading from the registry, so
                    // fail the license.

                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                    return(false);
                }
                else
                {
                    //
                    // this.licenseKeyString has changed to runtime application, so update
                    // licenseKey
                    //

                    try
                    {
                        licenseKey = new LicenseKey(this.licenseKeyString);
                    }
                    catch (ArgumentException)
                    {
                        licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                        return(false);
                    }
                }
            }

#if delete
/*                //
 *              // Here we check the registry to find if a runtime license exists.
 *              // If we do not find one, assume that this is the first time this
 *              // application is running.
 *              //
 *
 *              String regKeyName = registryCacheName + "\\" + type.GUID.ToString();
 *
 *              try
 *              {
 *                  regKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey( regKeyName, true );
 *              }
 *              catch( ArgumentException e )
 *              {
 *                  Trace.WriteLine("Exception building license.");
 *                  Trace.WriteLine(e);
 *                  licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
 *                  return false;
 *              }
 *              // BUGBUG: SecurityException ?
 *
 *
 *              if ( regKey == null )
 *              {
 *                  generateruntimefromdesign();
 *                  regKey =
 *              }
 *
 *              //
 *              // Read the license key string from the registry, and use it
 *              // to create a new licenseKey object.  regKey will
 *              // be null (undefined in VS) if the value doesn't exist.
 *              //
 *
 *              if ( regKey != null )
 *              {
 *                  // BUGBUG: SecurityException ?
 *                  this.licenseKeyString = (string) regKey.GetValue( "License" );
 *                  if ( this.licenseKeyString == NULL )
 *                  {
 *                      // fail.
 *                  }
 *
 *                  try
 *                  {
 *                      licenseKey = new LicenseKey(this.licenseKeyString);
 *                  }
 *                  catch( ArgumentException e)
 *                  {
 *                      licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
 *                      return false;
 *                  }
 *
 *                  regKey.Close();
 *              }
 *              else
 *              {
 *                  noRunTimeKeyFound = true;
 *              }
 *
 *
 *              //
 *              // If the license key string was not found in the registry,
 *              // it's assumed that this is the first run of an application.
 *              // Create a new runtime license key and save it
 *              // to the registry.
 *              //
 *
 *              if( noRunTimeKeyFound  )
 *              {
 *                  //
 *                  // Modify the license key to be a 'runtime evaluation' license by
 *                  // changing its type, setting the expiration date, and recalculating
 *                  // its hash value.  The serial number stays the same.
 *                  //
 *
 *                  licenseKey.Type = LicenseKeyType.RuntimeEvaluation;
 *                  licenseKey.ExpirationDate = DateTime.Now.AddDays( licenseKey.EvaluationDays );
 *                  licenseKey.Hash = licenseKey.CalculateHash( licenseComponent.MasterLicensePassword );
 *
 *
 *                  //
 *                  // Save the new runtime license key string, as it is needed
 *                  // later by GetKey().
 *                  //
 *
 *                  this.licenseKeyString = licenseKey.ToString();
 *
 *
 *                  //
 *                  // Write out to the Registry. CreateSubKey returns null if it fails.
 *                  // If an exceptions occurs, fail the license.
 *                  //
 *                  // Note that CreateSubKey may return a SecurityException, but the
 *                  // compiler throws an error.
 *                  //
 *                  // BUGBUG: proibably just need to refer to it as System.Security.SecurityException
 *                  //
 *                  try
 *                  {
 *                      regKey = Microsoft.Win32.Registry.CurrentUser.CreateSubKey( registryCacheName + "\\" + type.GUID.ToString() );
 *                      if ( regKey == null )
 *                      {
 *                          // BUGBUG: handle error.
 *                      }
 *                      regKey.SetValue( "License", (string) this.licenseKeyString );
 *                  }
 *                  catch( UnauthorizedAccessException e )
 *                  {
 *                      Trace.WriteLine("Exception writing to registry.");
 *                      Trace.WriteLine(e);
 *                      licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
 *                      return false;
 *                  }
 *                  //catch( SecurityException e)
 *                  //{
 *                  //    Trace.WriteLine("Exception writing to registry.");
 *                  //    Trace.WriteLine(e);
 *                  //    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
 *                  //    return false;
 *                  //}
 *
 *                  if( regKey != null )
 *                  {
 *                      regKey.Close();
 *                  }
 *              }
 *          } // end of if licenseType is runtime using design time eval license
 */
#endif //delete

            //
            // Now we have ensured that we have the right key ( The .lic file
            // was possibly replaced with a runtime key saved in the registry).
            // First validate that the key is authentic.
            //

            keyIsValid = licenseKey.IsHashValid(licenseComponent.MasterLicensePassword);
            if (!keyIsValid)
            {
                if (traceSwitch.TraceVerbose)
                {
                    Trace.WriteLine("IsKeyValid: License key is not properly signed.  Key=" + licenseKeyString);
                }
                Trace.Unindent();
                licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                return(false);
            }


            //
            // If the licenseKey is a runtime evaluation, check if:
            //   - expiration date is expired
            //   - expiration period is longer than maximum allowed
            //   - it has an absolute evaluation date, check if its
            //     not expired
            //   - a 'time-bomb' has been set for the component itself,
            //     and if so, should it go boom.
            //
            // If any of these returns a expired or invalid value, declare
            // that the key is not valid by returning false after setting
            // the licenseCheckFailureReason.  Otherwise return true.
            //

            if (licenseKey.Type == LicenseKeyType.RuntimeEvaluation)
            {
                if (traceSwitch.TraceVerbose)
                {
                    Trace.WriteLine("  License key is runtime evaluation.");
                    Trace.WriteLine("    Current Date:    " + DateTime.Now);
                    Trace.WriteLine("    Expiration Date: " + licenseKey.ExpirationDate);
                }

                //
                // Check whether the current date is beyond the expiration date.
                //

                if (DateTime.Now > licenseKey.ExpirationDate)
                {
                    if (traceSwitch.TraceVerbose)
                    {
                        Trace.WriteLine("IsKeyValid: License is expired.  ExpirationDate = " + licenseKey.ExpirationDate);
                    }
                    Trace.Unindent();
                    licenseCheckFailureReason = LicenseCheckFailureReason.EvaluationLicenseExpired;
                    return(false);
                }

                //
                // Check whether the expiration date is higher than possible - this points
                // to someone adjusting their system calender while building a component in
                // an attempt to have an eval license valid for a long time.
                //

                DateTime maxExpirationDate = DateTime.Now.AddDays(licenseKey.EvaluationDays);
                if (licenseKey.ExpirationDate > maxExpirationDate)
                {
                    if (traceSwitch.TraceVerbose)
                    {
                        Trace.WriteLine("IsKeyValid: License has invalid expiration date.");
                        Trace.WriteLine("  Evaluation Days:     " + licenseKey.EvaluationDays);
                        Trace.WriteLine("  Max Expiration Date: " + maxExpirationDate);
                        Trace.Unindent();
                    }
                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                    return(false);
                }
            }

            //
            // If its past the Absolute Expiration Date, fail it even if the evaluation
            // period is not expired
            //

            if (licenseKey.AbsoluteExpirationDate)
            {
                if (traceSwitch.TraceVerbose)
                {
                    Trace.WriteLine("  License key has absolute expiration date.");
                    Trace.WriteLine("    Current Date:    " + DateTime.Now);
                    Trace.WriteLine("    Expiration Date: " + licenseKey.ExpirationDate);
                }

                //
                // Check whether the current date is beyond the expiration date.
                //

                if (DateTime.Now > licenseKey.ExpirationDate)
                {
                    Trace.WriteLine("IsKeyValid: License is expired.  ExpirationDate=" + licenseKey.ExpirationDate);
                    Trace.Unindent();
                    licenseCheckFailureReason = LicenseCheckFailureReason.EvaluationLicenseExpired;
                    return(false);
                }
            }


            //
            // Check to see if a 'time-bomb' has been set for the component itself.
            //

            if (
                (licenseComponent.ExpirationDate.Ticks != (long)0) &&
                (DateTime.Now > licenseComponent.ExpirationDate)
                )
            {
                if (traceSwitch.TraceVerbose)
                {
                    Trace.WriteLine("IsKeyValid: Component has expired.  ExpirationDate=" + licenseComponent.ExpirationDate);
                }
                Trace.Unindent();
                licenseCheckFailureReason = LicenseCheckFailureReason.ComponentExpired;
                return(false);
            }

            //
            // Passed all the tests, so we have a valid key
            //

            return(true);
        }
Пример #8
0
 public LicXLicense(License l)
 {
     this.internalLicense = l;
     licenseKey = new LicenseKey( l.LicenseKey );
 }
Пример #9
0
 public LicXLicense(string licenseKeyString)
 {
     //licenseKey = new LicenseKey( licenseKeyString );
     licenseKey = new LicenseKey();
     internalLicense = null;
 }
Пример #10
0
 public LicXLicense(License l)
 {
     this.internalLicense = l;
     licenseKey           = new LicenseKey(l.LicenseKey);
 }
Пример #11
0
 public LicXLicense(string licenseKeyString)
 {
     //licenseKey = new LicenseKey( licenseKeyString );
     licenseKey      = new LicenseKey();
     internalLicense = null;
 }
Пример #12
0
        //
        // Returns false if it failed to generate run time LicenseKey 
        // either b/c an exception was thrown when creating or opening a 
        // registry subkey, or a regKey could not succesfully write to the
        // registry.
        //
        // Returns boolean newKeyInRegistry
        //

        private bool GenerateRunTimeLicenseKeyFromDesignTime(LicenseKey licenseKey, Type type)
        {
            Microsoft.Win32.RegistryKey regKey = null;
            bool newKeyInRegistry = false;
 
            //
            // Modify the license key to be a 'runtime evaluation' license by
            // changing its type, setting the expiration date, and recalculating
            // its hash value.  The serial number stays the same.
            //
                                       
            licenseKey.Type = LicenseKeyType.RuntimeEvaluation;
            licenseKey.ExpirationDate = DateTime.Now.AddDays( licenseKey.EvaluationDays );
            licenseKey.Hash = licenseKey.CalculateHash( licenseComponent.MasterLicensePassword );

            //
            // Write out to the Registry. CreateSubKey returns null if it fails.  
            // If null is returned or an exceptions occurs, catch it and return null. 
            //
                    
            try
            {     
                regKey = Microsoft.Win32.Registry.CurrentUser.CreateSubKey( registryCacheName + "\\" + type.GUID.ToString() );
                if ( regKey == null )
                {
                    Debug.WriteLine("Failed writing to registry.");
                    return newKeyInRegistry;           
                }
                regKey.SetValue( "License", (string) licenseKey.ToString() );
            }                    
            catch( UnauthorizedAccessException e )
            {
                Debug.WriteLine("Exception writing to registry.");
                Debug.WriteLine(e);
                return newKeyInRegistry;
            }
            catch( System.Security.SecurityException e)
            {
                Debug.WriteLine("Exception writing to registry.");
                Debug.WriteLine(e);
                return newKeyInRegistry;
            }
      
            if( regKey != null ) 
            {
                regKey.Close();
            }
                    
            //
            // Save the new runtime license key string, as it is needed
            // later by GetKey().
            //
            
            this.licenseKeyString = licenseKey.ToString();
          
            newKeyInRegistry = true;
                             
            return newKeyInRegistry; 
                                                                    
        }             
Пример #13
0
        //
        // This routine gets the runtime license key associated with an 
        // application.  It returns true if licence runtime key was 
        // retrieved from registry, or created and stored in registry.  
        // This is necessary ...
        //
    
        private bool GetApplicationRuntimeLicenseKey(LicenseKey licenseKey, Type type)
        {
            
            Microsoft.Win32.RegistryKey regKey = null;
            bool SuccessfulWriteToRegisty = false;

            //
            // Here we check the registry to find if a runtime license exists.
            // If we do not find one, assume that this is the first time this 
            // application is running.
            //

            String regKeyName = registryCacheName + "\\" + type.GUID.ToString();
                
            try
            {
                regKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey( regKeyName, true );
            }
            catch( ArgumentException e )
            {
                Debug.WriteLine("Exception trying to read registry.");
                Debug.WriteLine(e);
                return false;
            }
            catch( System.Security.SecurityException e)
            {
                Debug.WriteLine("Exception reading registry.");
                Debug.WriteLine(e);
                return false;
            }
            
           
            if ( regKey == null )
            {

                //
                // No key found in registry, so generate one and save it. 
                //

                SuccessfulWriteToRegisty = GenerateRunTimeLicenseKeyFromDesignTime(licenseKey, type);
                
                //
                // If there was a problem writing to the registry, 
                // return false thereby failing the license
                //

                if(!SuccessfulWriteToRegisty)
                {
                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                    return false;
                }
                try
                {
                    regKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey( regKeyName, true );
                }
                catch( ArgumentException e )
                {
                    Debug.WriteLine("Exception trying to read registry.");
                    Debug.WriteLine(e);
                    return false;
                }
                catch( System.Security.SecurityException e)
                {
                    Debug.WriteLine("Exception reading registry.");
                    Debug.WriteLine(e);
                    return false;
                }

            }
            
            if ( regKey != null )
            {                
                this.licenseKeyString = (string) regKey.GetValue( "License" );
                if ( this.licenseKeyString == null )
                {
                    //
                    // Someone probably deleted key manually.  Fail the license.
                    //

                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                    regKey.Close();
                    return false;

                }       
                    
                regKey.Close();
            }
            else
            {

                licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                 
                return false;
            }

            
              
            //
            // this.licenseKeyString updated               
            //

            return true;
        }
Пример #14
0
        //
        //  GetKey() is defined by LicFileLicenseProvider.  It is called during
        //  GetLicense() processing in order to populate the LicenseKey property
        //  of the License object returned to the caller.
        //

        protected override string GetKey(Type type)
        {
            string key;
            LicenseKey licenseKey;

            if( traceSwitch.TraceVerbose )
            {
                Trace.WriteLine( String.Format( "GetKey(type={0})", type) );
            }
            Trace.Indent();

            //
            // We return whichever license key string we were presented in IsKeyValid(),
            // unless we had been presented a 'design time evaluation' license.
            // In the latter case, we generate a new license key that encodes the
            // evaluation expiration date in it.  This license key will subsequenty
            // be embedded in the executable being built.
            //

            key = this.licenseKeyString;

            //
            // Myk, what do we do if we catch an exception here?  we should
            // never, because key should be valid.  If we return null, will we
            // still get a license?  In that case, we should never throw any
            // exceptions.
            //

            try
            {
                licenseKey = new LicenseKey( key );
            }
            catch( ArgumentException)
            {                
                licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                
                return null; 
            }             
            
            if( traceSwitch.TraceVerbose )
            {
                Trace.WriteLine( "GetKey: License type is " + licenseKey.Type);
            }

            if( licenseKey.Type == LicenseKeyType.DesignTimeEvaluation )
            {
                //
                // Modify the license key to be a 'runtime evaluation' license by
                // changing its type, setting the expiration date, and recalculating
                // its hash value.
                //

                licenseKey.Type = LicenseKeyType.RuntimeEvaluation;
                licenseKey.ExpirationDate = DateTime.Now.AddDays( licenseKey.EvaluationDays );
                licenseKey.Hash = licenseKey.CalculateHash( licenseComponent.MasterLicensePassword );
                
                key = licenseKey.ToString();
            }

            if( traceSwitch.TraceVerbose )
            {
                Trace.WriteLine("Generated license key: " + key);
            }
            Trace.Unindent();

            //
            // Return the new license key string to be embedded.
            //

            return key;
        }
Пример #15
0
        //
        // This routine gets the runtime license key assocaited with an 
        // application.  This is necessary ...
        //protected LicenseKey GetApplicationRuntimeLicenseKey()
        //{
        //}

      
        //
        //  IsKeyValid is defined by LicFileLicenseProvider, and is called
        //  during processing of GetLicense to determine if a given license
        //  key string represents a valid license.
        //
        //  Notice that we are only given the string and the type of the
        //  class being licensed.  We need to use the LicXLicenseComponent
        //  that is a member of the licensed instance, so we pull that out
        //  of the class field where it had been stored earlier.
        //
        //  Note that in the case of an application licensed with an evaluation
        //  license, we may have to go to the registry to find an appropriate
        //  license key string.
        //
        
        protected override bool IsKeyValid(string licenseKeyString, Type type)
        {
            bool keyIsValid;
            bool RunTimKeyFound = false;           
            LicenseKey licenseKey;            

            if ( traceSwitch.TraceVerbose )
            {
                Trace.WriteLine( String.Format( "IsKeyValid({0}, {1})", licenseKeyString, type ));
            }
            Trace.Indent();

            //
            // Save LicenseKeyString for later use in GetKey.  If this is a
            // runtime application using a design time key, it will be changed
            // and stored for GetKey()
            //

            this.licenseKeyString = licenseKeyString;

            //
            // Create a LicenseKey object with the given license key string.
            // The LicenseKey can throw an Exception for the int32.parse 
            // method.  Fail it if does, b/c something is a matter with our 
            // license key string.
            //

            try
            {                
                licenseKey = new LicenseKey(licenseKeyString);
            }
            catch( ArgumentException )
            {                
                licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                
                return false;
            } 
            
            //
            // If we are being invoked at runtime, and the license key string
            // we are given is of type "design time evaluation", we are dealing
            // with a licensed application (as opposed to a component).  In 
            // this case, the runtime license we use needs to be in the 
            // registry.  (The first time the application is run, we need to
            // create this registry license).
            //
            // BUGBUG: It doesn't appear that the check for 
            // BUGBUG: "!licenseKey.AbsoluteExpirationDate is ever needed?  
            // BUGBUG: Need to do a full test cycle to make sure...
            //
            
            if( 
                ( LicenseManager.CurrentContext.UsageMode == LicenseUsageMode.Runtime ) &&
                ( licenseKey.Type == LicenseKeyType.DesignTimeEvaluation ) && 
                ( !licenseKey.AbsoluteExpirationDate )
                )
            {               
                
                RunTimKeyFound = GetApplicationRuntimeLicenseKey( licenseKey, type);

                if(!RunTimKeyFound)
                {
                    // there was a problem writing or reading from the registry, so
                    // fail the license.
                    
                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                    return false;
                }
                else
                {
                    // 
                    // this.licenseKeyString has changed to runtime application, so update
                    // licenseKey
                    //

                    try
                    {                
                        licenseKey = new LicenseKey(this.licenseKeyString);
                    }
                    catch( ArgumentException )
                    {                
                        licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                
                        return false;
                    } 
                }
            }
                
#if delete 
/*                //
                // Here we check the registry to find if a runtime license exists.
                // If we do not find one, assume that this is the first time this 
                // application is running.
                //

                String regKeyName = registryCacheName + "\\" + type.GUID.ToString();
                 
                try
                {                          
                    regKey = Microsoft.Win32.Registry.CurrentUser.OpenSubKey( regKeyName, true );
                }
                catch( ArgumentException e )
                {
                    Trace.WriteLine("Exception building license.");
                    Trace.WriteLine(e);
                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                
                    return false;
                }
                // BUGBUG: SecurityException ?


                if ( regKey == null )
                {
                    generateruntimefromdesign();
                    regKey = 
                }

                //
                // Read the license key string from the registry, and use it
                // to create a new licenseKey object.  regKey will 
                // be null (undefined in VS) if the value doesn't exist. 
                // 
                
                if ( regKey != null )
                {
                    // BUGBUG: SecurityException ?
                    this.licenseKeyString = (string) regKey.GetValue( "License" );
                    if ( this.licenseKeyString == NULL )
                    {
                        // fail.
                    }

                    try
                    {
                        licenseKey = new LicenseKey(this.licenseKeyString);
                    }
                    catch( ArgumentException e)
                    {
                        licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                
                        return false;
                    } 
                    
                    regKey.Close();
                }
                else
                {
                    noRunTimeKeyFound = true;
                }

                                
                //
                // If the license key string was not found in the registry, 
                // it's assumed that this is the first run of an application.  
                // Create a new runtime license key and save it 
                // to the registry.
                //
 
                if( noRunTimeKeyFound  )
                {
                    //
                    // Modify the license key to be a 'runtime evaluation' license by
                    // changing its type, setting the expiration date, and recalculating
                    // its hash value.  The serial number stays the same.
                    //
                                       
                    licenseKey.Type = LicenseKeyType.RuntimeEvaluation;
                    licenseKey.ExpirationDate = DateTime.Now.AddDays( licenseKey.EvaluationDays );
                    licenseKey.Hash = licenseKey.CalculateHash( licenseComponent.MasterLicensePassword );

    
                    //
                    // Save the new runtime license key string, as it is needed
                    // later by GetKey().
                    //

                    this.licenseKeyString = licenseKey.ToString();

    
                    //
                    // Write out to the Registry. CreateSubKey returns null if it fails.  
                    // If an exceptions occurs, fail the license. 
                    //
                    // Note that CreateSubKey may return a SecurityException, but the 
                    // compiler throws an error.
                    //
                    // BUGBUG: proibably just need to refer to it as System.Security.SecurityException
                    //
                    try
                    {     
                        regKey = Microsoft.Win32.Registry.CurrentUser.CreateSubKey( registryCacheName + "\\" + type.GUID.ToString() );
                        if ( regKey == null )
                        {
                            // BUGBUG: handle error.
                        }
                        regKey.SetValue( "License", (string) this.licenseKeyString );
                    }                    
                    catch( UnauthorizedAccessException e )
                    {
                        Trace.WriteLine("Exception writing to registry.");
                        Trace.WriteLine(e);
                        licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                        
                        return false;
                    }
                    //catch( SecurityException e)
                    //{
                    //    Trace.WriteLine("Exception writing to registry.");
                    //    Trace.WriteLine(e);
                    //    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                        
                    //    return false;
                    //}
      
                    if( regKey != null ) 
                    {
                        regKey.Close();
                    }                                            
                }
            } // end of if licenseType is runtime using design time eval license              
*/
#endif //delete

            //
            // Now we have ensured that we have the right key ( The .lic file
            // was possibly replaced with a runtime key saved in the registry).
            // First validate that the key is authentic.
            //

            keyIsValid = licenseKey.IsHashValid( licenseComponent.MasterLicensePassword );
            if( !keyIsValid )
            {
                if( traceSwitch.TraceVerbose )
                {
                    Trace.WriteLine("IsKeyValid: License key is not properly signed.  Key=" + licenseKeyString);                
                }
                Trace.Unindent();
                licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;
                return false;
            }

             
            //
            // If the licenseKey is a runtime evaluation, check if:
            //   - expiration date is expired
            //   - expiration period is longer than maximum allowed
            //   - it has an absolute evaluation date, check if its
            //     not expired
            //   - a 'time-bomb' has been set for the component itself,
            //     and if so, should it go boom.
            // 
            // If any of these returns a expired or invalid value, declare
            // that the key is not valid by returning false after setting
            // the licenseCheckFailureReason.  Otherwise return true.
            //

            if( licenseKey.Type == LicenseKeyType.RuntimeEvaluation )
            {
                if( traceSwitch.TraceVerbose )
                {
                    Trace.WriteLine("  License key is runtime evaluation.");                
                    Trace.WriteLine("    Current Date:    " + DateTime.Now);
                    Trace.WriteLine("    Expiration Date: " + licenseKey.ExpirationDate);
                }

                //
                // Check whether the current date is beyond the expiration date.
                //

                if( DateTime.Now > licenseKey.ExpirationDate )
                {
                    if( traceSwitch.TraceVerbose )
                    {
                        Trace.WriteLine("IsKeyValid: License is expired.  ExpirationDate = " + licenseKey.ExpirationDate);                    
                    }
                    Trace.Unindent();              
                    licenseCheckFailureReason = LicenseCheckFailureReason.EvaluationLicenseExpired;
                    return false;
                }                

                //
                // Check whether the expiration date is higher than possible - this points
                // to someone adjusting their system calender while building a component in
                // an attempt to have an eval license valid for a long time.
                //

                DateTime maxExpirationDate = DateTime.Now.AddDays( licenseKey.EvaluationDays );
                if( licenseKey.ExpirationDate > maxExpirationDate )
                {          
                    if( traceSwitch.TraceVerbose )
                    {
                        Trace.WriteLine("IsKeyValid: License has invalid expiration date.");
                        Trace.WriteLine("  Evaluation Days:     " + licenseKey.EvaluationDays);
                        Trace.WriteLine("  Max Expiration Date: " + maxExpirationDate);
                        Trace.Unindent();
                    }
                    licenseCheckFailureReason = LicenseCheckFailureReason.InvalidLicenseKey;                    
                    return false;
                }                
            }

            //
            // If its past the Absolute Expiration Date, fail it even if the evaluation
            // period is not expired
            //

            if( licenseKey.AbsoluteExpirationDate )
            {
                if( traceSwitch.TraceVerbose )
                {
                    Trace.WriteLine("  License key has absolute expiration date.");                
                    Trace.WriteLine("    Current Date:    " + DateTime.Now);
                    Trace.WriteLine("    Expiration Date: " + licenseKey.ExpirationDate);
                }

                //
                // Check whether the current date is beyond the expiration date.
                //

                if( DateTime.Now > licenseKey.ExpirationDate )
                {
                    Trace.WriteLine("IsKeyValid: License is expired.  ExpirationDate="+licenseKey.ExpirationDate);
                    Trace.Unindent();
                    licenseCheckFailureReason = LicenseCheckFailureReason.EvaluationLicenseExpired;					
                    return false;
                }
            }      


            //
            // Check to see if a 'time-bomb' has been set for the component itself.
            //

            if( 
                ( licenseComponent.ExpirationDate.Ticks != (long)0 ) && 
                ( DateTime.Now > licenseComponent.ExpirationDate )
                )
            {
                if( traceSwitch.TraceVerbose )
                {
                    Trace.WriteLine("IsKeyValid: Component has expired.  ExpirationDate=" + licenseComponent.ExpirationDate); 
                }               
                Trace.Unindent();
                licenseCheckFailureReason = LicenseCheckFailureReason.ComponentExpired;
                return false;
            }
            
            //
            // Passed all the tests, so we have a valid key
            //
   
            return true;
        }